{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inner workings of the `call-dots`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup the environment first\n",
    "\n",
    "# read: https://github.com/mirnylab/cooler/issues/138 for more details:\n",
    "\n",
    "# !export MKL_NUM_THREADS=1 - # not working in a notebook ((\n",
    "# instead do this, after making sure mkl is installed\n",
    "import mkl\n",
    "mkl.set_num_threads(1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# are you developing?\n",
    "# turn module reloading on\n",
    "\n",
    "# %load_ext autoreload\n",
    "# %autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# neccessary modules to be imported\n",
    "\n",
    "import os.path as op\n",
    "from scipy.stats import poisson\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import cooler\n",
    "\n",
    "from cooltools import dotfinder\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as colors\n",
    "import matplotlib.ticker as ticker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: replace this with \"wget some-real-data\" to make notebook self-sufficient\n",
    "\n",
    "# input files to play with\n",
    "# pick Rao et al primary @10kb to enable comparison\n",
    "\n",
    "# what I have here is Rao et al 2014 sample for GM cells\n",
    "# the dataset that they refer to as \"primary\" in the paper\n",
    "# the cooler created using hic2cool tool\n",
    "# and what I have here is an older version before divisive/multiplicative\n",
    "# balancing weights situation happened\n",
    "path = \"/home/venevs/DOTS_TESTING/prim_rep_rao_Mar19\"\n",
    "basename = \"GM12878_insitu_primary_30.KR\"\n",
    "\n",
    "# this is a 10kb cooler file\n",
    "# and we should also have expected calculated for 10kb\n",
    "\n",
    "COOL10=\"{}/{}.cool\".format(path,basename)\n",
    "EXP10=\"{}/{}.cis.expected\".format(path,basename)\n",
    "\n",
    "LOOP10=\"{}/cloops_{}.bedpe\".format(path,basename)\n",
    "# # HDF10=test_scores$TESTIDX\\_$BASENAME.10000.hdf\n",
    "FLOOP10=\"{}/cloops_{}.bedpe.postprocess\".format(path,basename)\n",
    "\n",
    "RAOLOOPS=\"/home/venevs/DOTS_TESTING/rao_combined_hic/Rao2014_GM12878_primary_and_replicate_HiCCUPS_looplist.txt\"\n",
    "RAOLOOPS=\"/home/venevs/DOTS_TESTING/prim_rep_rao/Rao2014_GM12878_primary_HiCCUPS_looplist.txt\"\n",
    "\n",
    "# keeping some of the relevant CLI commands here\n",
    "# useful for preprocessing cooler files - before calling dots\n",
    "\n",
    "# 0. consider adding downloading command for Rao data e.g.\n",
    "# 0. also condsider showing hic2cool usage here to turn .hic to .cool\n",
    "\n",
    "# 1. re-balancing - cis-only is worth checking out at the very least ...\n",
    "# cooler balance -p {threads} --ignore-diags 1 --force --name 'wsnake' {input}::/resolutions/{res}\n",
    "\n",
    "# 2. calculation of expected\n",
    "# cooltools compute-expected -p {threads} --weight-name 'wsnake' --drop-diags 1 {input[0]}::/resolutions/{res}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**provide arguments to replace CLI interface**\n",
    "\n",
    "instead of providing command line arguments to the `call-dots` tool we are going to provide corresponding argumnets right in the notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# specify parameters for call-dots\n",
    "cool_path = COOL10\n",
    "expected_path = EXP10\n",
    "expected_name = 'balanced.avg'\n",
    "nproc = 8\n",
    "max_loci_separation = 1000000\n",
    "max_nans_tolerated = 4\n",
    "tile_size = 10000000\n",
    "fdr = 0.1\n",
    "dots_clustering_radius = 21000\n",
    "verbose = True\n",
    "balancing_weight_name = \"weight\"\n",
    "output_scores = 'xxx'\n",
    "output_hists = 'yyy'\n",
    "output_calls = 'zzz'\n",
    "score_dump_mode = 'parquet'\n",
    "# score_dump_mode = 'local'\n",
    "temp_dir = './'\n",
    "no_delete_temp = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**load cooler and expected**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tokenization took: 46.27 ms\n",
      "Type conversion took: 19.94 ms\n",
      "Parser memory cleanup took: 0.01 ms\n",
      "Tokenization took: 31.56 ms\n",
      "Type conversion took: 19.25 ms\n",
      "Parser memory cleanup took: 0.00 ms\n",
      "Tokenization took: 9.59 ms\n",
      "Type conversion took: 5.80 ms\n",
      "Parser memory cleanup took: 0.00 ms\n"
     ]
    }
   ],
   "source": [
    "clr = cooler.Cooler(cool_path)\n",
    "\n",
    "expected_columns = ['chrom', 'diag', 'n_valid', expected_name]\n",
    "expected_index = ['chrom', 'diag']\n",
    "expected_dtypes = {\n",
    "    'chrom': np.str,\n",
    "    'diag': np.int64,\n",
    "    'n_valid': np.int64,\n",
    "    expected_name: np.float64\n",
    "}\n",
    "expected = pd.read_table(\n",
    "    expected_path,\n",
    "    usecols=expected_columns,\n",
    "    index_col=expected_index,\n",
    "    dtype=expected_dtypes,\n",
    "    comment=None,\n",
    "    verbose=verbose)\n",
    "# include Geoff's fix for the datatypes in expected"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**we'll do everyhting for `chr1` only to save time (reconsider it later ...)**\n",
    "\n",
    "demonstration purposes only this way ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# beware of chromosome naming converntion, i.e. \"chr1\" vs \"1\" ...\n",
    "expected = expected.loc[[\"1\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**some validation**\n",
    "Just making sure that expected anb cooler are \"compatible\"\n",
    "i.e. they refer to the same chromosomes and those chromosomes have the same length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/venevs/DOTS_TESTING/prim_rep_rao_Mar19/GM12878_insitu_primary_30.KR.cool and /home/venevs/DOTS_TESTING/prim_rep_rao_Mar19/GM12878_insitu_primary_30.KR.cis.expected passed cross-compatibility checks.\n"
     ]
    }
   ],
   "source": [
    "# Input validation\n",
    "# unique list of chroms mentioned in expected_path\n",
    "# do simple column-name validation for now\n",
    "get_exp_chroms = lambda df: df.index.get_level_values(\"chrom\").unique()\n",
    "expected_chroms = get_exp_chroms(expected)\n",
    "if not set(expected_chroms).issubset(clr.chromnames):\n",
    "    raise ValueError(\n",
    "        \"Chromosomes in {} must be subset of \".format(expected_path) +\n",
    "        \"chromosomes in cooler {}\".format(cool_path))\n",
    "# check number of bins\n",
    "# compute # of bins by comparing matching indexes\n",
    "get_exp_bins = lambda df, ref_chroms: (\n",
    "    df.index.get_level_values(\"chrom\").isin(ref_chroms).sum())\n",
    "expected_bins = get_exp_bins(expected, expected_chroms)\n",
    "cool_bins = clr.bins()[:][\"chrom\"].isin(expected_chroms).sum()\n",
    "if not (expected_bins == cool_bins):\n",
    "    raise ValueError(\n",
    "        \"Number of bins is not matching: \",\n",
    "        \"{} in {}, and {} in {} for chromosomes {}\".format(\n",
    "            expected_bins,\n",
    "            expected_path,\n",
    "            cool_bins,\n",
    "            cool_path,\n",
    "            expected_chroms))\n",
    "if verbose:\n",
    "    print(\"{} and {} passed cross-compatibility checks.\".format(\n",
    "        cool_path, expected_path))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**prepare some other parameters**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "we are dealing with the data binned at 10000\n"
     ]
    }
   ],
   "source": [
    "# Prepare some parameters.\n",
    "binsize = clr.binsize\n",
    "loci_separation_bins = int(max_loci_separation / binsize)\n",
    "tile_size_bins = int(tile_size / binsize)\n",
    "balance_factor = 1.0  #clr._load_attrs(\"bins/weight\")[\"scale\"]\n",
    "\n",
    "print(\"we are dealing with the data binned at {}\".format(binsize))\n",
    "\n",
    "# clustering would deal with bases-units for now, so supress this for now\n",
    "# clustering_radius_bins = int(dots_clustering_radius/binsize)\n",
    "\n",
    "# pre-defined kernel types that are going to be used in the analysis\n",
    "ktypes = ['donut', 'vertical', 'horizontal', 'lowleft']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kernels used for calculating local enrichment of a pixel\n",
    "\n",
    " - Dots observed on Hi-C heatmaps as *small* and concentrated clusters of locally enriched pixels.\n",
    " - Biologically relevant sizes of such clusters and their surroundings are empirically defined at `~50kb` for the diameter of clusters, and `~100kb` for the diameter of the local surrounding\n",
    " - Several types of kernels (i.e. local environments) could be used to rule out unwanted enrichment types, e.g. elongated clusters, large corners, etc.\n",
    " - One can choose from pre-defined set of kernels from *Rao et al 2014*, or provide custome ones\n",
    " - Even for the predefined set of kernels one can control their parameters `w` and `p`, where `2w+1` is the outter dimensions of kernel's footprint and `2p+1` is the inner one, the approximate size of an enriched cluster of pixels\n",
    " - function `recommend_kernel_params` would yield recommended `w` and `p` for a given bin size, as in *Rao et al 2014*, otherwise feel free to experiment with those"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kernel parameters w=5 p=2\n"
     ]
    }
   ],
   "source": [
    "w,p = dotfinder.recommend_kernel_params(binsize)\n",
    "print(\"Kernel parameters w={} p={}\".format(w,p))\n",
    "\n",
    "kernels = {k: dotfinder.get_kernel(w, p, k) for k in ktypes}\n",
    "# list of tile coordinate ranges\n",
    "tiles = list(\n",
    "    dotfinder.heatmap_tiles_generator_diag(\n",
    "        clr,\n",
    "        expected_chroms,\n",
    "        w,\n",
    "        tile_size_bins,\n",
    "        loci_separation_bins\n",
    "    )\n",
    ")   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(1, 0, 'Excluded from calculation'),\n",
       " Text(1, 0, 'Included in calculations')]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzUAAACuCAYAAAAPpSPxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XmcXlV9x/HvlwSiskxEwK0KVBCtKCioxYVFqEVnZBMLhVIjYF2L2tpWq2DUooi7hVpBlEVCqSiIE0iAQACJmCCrIItKbBGsBpxBthDCr3+c85Cbm+eZec5M5snc4fN+veY1z3Pvueece+557r2/uzoiBAAAAABNtd66rgAAAAAAjAdBDQAAAIBGI6gBAAAA0GgENQAAAAAajaAGAAAAQKMR1AAAAABotEkT1NheaHvhJKjHTNuzbb+iy/Sn2r5rouu1tuV55Hnea5nt3XPbrlcbvpXtsD1rgsoN27NHSTMrp9tmIuowUXKbhu3d13VdRtL6Tdme3oOy1vn6Ms/vG8Yx/ajzUPndHDnWctaVbn6Tk1Evtw3jWS/aXs/2V2zfY/tx2+fl/Gbb/tMu81ho+0fFFV/H8n7H0nVdD2CymTRBzSQyU9InJHUV1AA1uyv1n/pv6x5Ju0ia2+sKYUp6b/5blz4hacxBDTBOB0r6gKTPS3qtpH+WtJVSv+wqqAEwtUz4EUWMj+0ZEbF8XdcDI7O9vqTHOo3Py/Dq3tWo91ptELzRd8K01gcRccu6rstUYNuS1o+IR9d1XVDsxfn/VyLicUmy/Zx1WJ81sP0GemudnKmxfbDtW20vt32z7f07pNvO9rm2h2w/bPtq23vX0rQu+djW9lzbD9j+te1jqpcAVS692ard9PnzVpLuzKNOzumLT43bfoftFbY/Uhm2me2v2/5Nnu9bbf9dbbpWHXe1/V3bQ5J+ksedavsu2y+3faXth2zfYfvdbcrf2vaZtn+fy7q+Uxs/Gdj+q9yuL2sz7kLb11e+T7f90Ur/vNv2F20/pZKmdcnEe20fb/tuScslfUXpKKEkrWj1n9o0s2rl72b7YtvDth+0fYPtIyrjD7Z9aV6WD9i+zvbb12Lb7GT7/2x/vzWP42yDmZV+/Oe5H96f8/haNY+cz9Nsf872nbYfzf8/5trlew2z9UjrIql43ba97fm2H5D033ncapduVdZV9b+llTTr2/4320tzWy/N39evpGkt13fZ/pTTpT1Dtn9o+0+q5eWPH6uUNTuPe6Xtc/L66mHbt9n+jO2nro3GdVqX/sT2z20/vzL8gNyOD+U6f7c6PqdZavs7tg+3faukRyX1dzvflXzemX+rj9heZvsU25uujfmbjGxvYvuE/Dtenpfph2w7j5+W2+vjlWlemtv0R7W87rJ9/Cjl7WZ7ge0/Oq0X59vevjJ+qaTZ+etKr1q3XpaHXVzpl7sXzuvR+fdxaGXY1h5lm9rF7/VHtveyfW3uoz+zvV+b8newfb7tP+Tfz1W2X18yD8CTVc93HGzvJWmOpDskHaB06virkrarpXuOpB9J2kHS+yX9laQhSXNtv6lN1udKulTSfpLOk/RJSaU7f/fkOknSZ5UuFyq6ZMj2RyV9Q9I7I+K4PGwTSVdJ6ldaEfdL+qGkr9v++zbZnKkUXB0o6SOV4Zsotd13JO0raUnOY49K+c9TCoR2kPQhSftIulbS92zv0+18TDHnSxqW9DfVgbafKWkvSWdUBn9H0seV2rlfqR8cobRM6j4m6YWS/k7S/pK+IOmUPO51WtV/2rK9r6QFkjaQ9C6lZfotSVtWkv2ppHMkHarUt38o6ZtuE8yWsv1GSQuVfjtvi4hH8qjxtMEjlXFnSPql0m/q65LeJ+mjlfKnS5ov6UildcCbJH1T0tFK64WmGnFdNIZ12w8kXa70W/5yhzJ3qf0dIOlhST+vpDlNaX1yuqQBSd+W9C95eN1HJW0j6XClS3x20erLv9WvT62U+c087PmSrpf0bkl7Ky3bw3N54+J04OkqSSHpdRHxP3n4uyV9T9ItSuvNd0naXtLltjeuZbOHpH9QWi57S7qxMm60+Zbt4yT9h6RLlJbJP+V8LrQ9bbzzONk4BeRzJb1D0hclvUXSPElfknSsJEXESklXaPXLEd+g1AdfZXvDnNd2kp6rVcFHu/L6ldaLDyitsw+RtLGkK/P2TUrrmlPz51b/u0xpHSNJR1WGX9vtfNr+D6XfxFsi4sw8vHSb2un3+gKl38KXlH6f90g6x5V7HJ3u5V0kaVNJ75T0Vkn3SrrE9k7dzAfwpBYRPf1T2iDdImm9yrBXK22kFlaGfUHpcp5tKsOmSbpN0rWVYbPztO+olXOTpIsq32fldFvV0s1OzfDE961yuiO7nJ9TJd2lFCD+u6QHJfXX0hyttLO3bW34yZKWSZpeq+OXO5QTkvaoDJuRpz+pMuwUSb+X9Iza9BdLur7TfE/1v9zWd9X63QdzH3t2/v763MZ/W5v20Dx8x1ofuVaS2/Wn1jJt069m5e+WtFTSNdU6jTIP6yldMnqypBtq40LS7FGmb/WvbfI8PSrpU7U0a6MNWuV8sjZ8UNLtle+H5XS71tJ9LNdti/x995xu93Xdj0Zp39ayH21dVLpu+0Cbshaqsr6sjXuqpMVKB46ekYdt366PKAWvIellteV6eS3dh/Pw59T63L+N0ibOffZvJD2uynpppHlo87s5Ummn8m5JF0h6WiXNRkoHLb7VZtpHJX2wMmyppIckPatDOSPOd063UtIxtXSvzen2K/lNTsY/rblNHFBl3VUZ/k2ls7Ob5e8fUgpiZuTv5ykdzHhA0l/mYe+WtELSRrV2n1XJ9xeSFtTK2kRpW/eVyrB/U20bplXrir26nNeFSgcYZigFxb+X9KpamqJtqjr/Xleosg8gaYvcl/61MmyB0oGIDSrDpuVh51WGnSpp6bruK/zxN9n+enqmJh/FeqWkcyJfAytJEfETpY1N1a6Sro6IX1TSrZR0lqQd89mPqvrZlJ8pHTHshemS/kvpiNJeEVGvy95KR3rudLq0Z3rlKPUzJP1ZLf25Hcp5KCKeOMIV6VrdO7T6fO6ttNEfblPWDm3a7cniDKUjhNUjiYdJuiQi7snf91baCfpere0uyuN3reV5XkSExmY7pTMy36z+FuqcLqs8y/ZvlDaKK5R28LbrNE0XPqi0UfxARBxTG7c226D+O7hJa/bVX0ta1Kas9SX9eclMTSKjrYtK122d1gdryJcDnaYUuPZHxL2VMqV0Fq6q9X23Uebhpvx/1HVqvlTpc7Z/qbTTu0Lp92dJ2446E+3tqnT0+xJJ+0TEQ5Vxuyjt9J5Z60d3SbpVa/bZqyPitx3KGW2+/0Lp4EK9rJ9Iur9NWVPBrkoB6Vm14d9ROsvcOmt3maSnSHpNPruzm9J25yqtWu++QdKSiHigXUG2t1U6o1Fv34ck/VgT074bK61zdlI6+7e4Nr50m9rp93pHRNzR+hIRv5P0O+W+5XR55m6Svivp8Uo5Vur3U7FvAWtVrx8UsJnSzsr/tRlXH7appOvapPut0o/86UobkZb7aumWK61ge2ETpct0LlU6Qlq3hdJOxooO0z+j9v2etqmkP7QZVp/PLST9bf7rVNb9HcZNZVcqBc6HKZ3Kf7HSE+6ql6RtobSRbrvBVffLqRutvDo+Dtz2RkpHAx9Sumzol0oBx3uULo8Zq4Ml/UbpyGTd2myDdr/JGbWytlT3v4umGG1dVLpuK+lnn1K67O2NEXF7rcx2ef22Nr6l3TxI3a1Tv610WecxSpehPSjpVZJO7HL6dt6sdEbmGxFRfyDHFvn/JR2mra83S/ustKrerbJ+ofaa2mdHsqmk+2LNG97rfecGpUul9lDqv5soBaIvknRADrh3VzrT3EmrfU/Rqkt5q/6ntPJdeL6kl0g6OSJu61Cnkm1qp/5V71vS6uuGTZXOyhyd/9Zge72RDoIBT3a9DmqWKe3APLPNuGcqHbVtuU/Ss9qke5bSKd52K4iRtK7136A2fG1shO5T2jkelHSW7UNqG957lY7IfKDD9PUV6ViP/rfKulLS5zqMv3sceTdWRITt70j6oO33KAU3D2j1o2r3KvWTTjdl1ttuPMtpWf7/3BHS7KK00//6iHjiZluP/z0ob5V0kqSFtt9QO2rdyza4V+nesb/qMH7pOPKezErXbV21se1DlC7dOzwiFrYps1XGL2tlSmlZjJvTgyD2Vbrs6quV4S8dZ9ZHS3qj0n0rb4qIqyrjWnWfJenmNtP+sfZ9vH1WuS7tDjKtlXacZO6TtKntDWL1p8St1nfyOvZypbMxf1S6NOsPti9VulTstZI21wj302hV+31U7YPUiXhK3c1KAfcZth+OiH9oU6eSbepY+9eQ0hmxE5Xue1sDAQ0wsp4GNRGx0vYSSQfanh2rHsP4aqVra6tBzeVKO6BbRcTSnG6apIMkXRcR9Q3VaFp5by/p9pzfdKWNU1XraFTRk3oiYmG+yfcCSf9l++BKYDNP0t9L+p98ynkizVPaGb45Ih6e4LKa5gylewgOULpH5Hu1y1jmKd0k2hcRC8ZYRrX/jNRHb1faaT/S9kkdLuF6Wv7/xJkM209X2mkcj98oHTG9TNJlObBpHV1cG23QrXlKAdYDEXHrBJc1maztdZts76L0kInjIuLUDmVK6SzdsZXhrSc8XVFaptIOZn09OUPpaHP97NusMeRftUIp+D1L0jzbb46IK/O4RUq/tW0iot1DD9ami5V2PJ8fERdPcFmTxeVKD0N4m1Z/aELrvrzqo+ovU7oRfqXSlQuS9FOls3Wzc/pqQFp3m9J68SWRH7RTaKzb77NsPyZpTj4b8sHK6J5sUyPiQdtXKt07di0BDFBuXbyn5hNK16+eZ/sbSkduPqlVp7Jbvqy0IbzY9ieUTu++V+lJS/1jKHeJ0hHKz+frfZfn/GbU0v2f0pGZg23fqLQyvrNybXpHEXGl02NZL5R0dg5sVuR5OUjp6S1fVlpxb6h0Wv71ETHendSqY5QugbvC9glKG4inKwVzfxoR47lsqdEi4nbbP5F0nNIZkjNq4xfaPkvpiTRfUmrHx5UC7jdL+pfaJT3ttN4f8o+2L5S0MiKuaVOXsP1BSd+XdKnt/1S6GfXFSjfIf0JpZ+1+SSfm38CGSkHZMkl9xQ2wevn3OD3qdIHSGZs9IuLutdQG3TpT6YlKC2x/UenylQ2UrqnfR+mm64dGmL6p1uq6LV/Tf57S/SM/tF29F2l5RFwXETfn5To7H8xZpLSjdrSksyLixjUyHt0tSo9Dnqd01uLuiLjb9tVK/f8epb56uEY+I9mViFhh+2ClfnOh7f6IuDwi7rf9T0q/k82V1r/DuczdlB5GMGe85ec6/NL25ySdkJ/kdbnSmc3nKd1v883qfY9TxIVKN9P/Z27fm5XWBUdK+mxELKukvVTpEvNdlc9s5IOZVyg9cOCKkQKDvF58n6Qf2N5A6ZHIy5Su5HiN0oHBL41Q19uVHsJxuO37lLbzt3VzoCAivmv7caWrLdaLiKPyqF5uU/9B6QDDfNunKF3KtpnSpdLTIuIjI00MPNn1/JHOEXGJ0hGe7ZR26P5J6cbl22rp7lZ6LO7NSk9QOUfpmtP+iJg3hnIfUzrC/b9KN0mfqHTU7dRauseVVtZPVzr9vUTpEZbdlnOVpL9Uuqb8u/mU/bDSCvkCpaPg85WOqu6rkU/FF4v0iNOdlXYQP6M0j19X2rhfOsKkTxatBwb8Ru3b/m+UjigeqPRoznOUHrt7h9rfC1Y3qPS41/cq3di6pFPCiPiB0o6QlK4fP1/p0chL8/jfKz26dFqux2eVnjhUv9l7TPJlZ3soHT1daLu14zneNui2/BVKv5WTleb7AqUd1rcr7XRPyRciru11W552C6UjvIuU+l3rr3p55duVdjQPV2rrI/L3t49pRlKfeFDpMeNLlJahJP210tH5E5XWr79V50tvi+T1+CFKv5ULnB9nHxHfUAqEt1P6jV+odLBsutJ9PWtNRPyr0rzuqrTT/QOl9foflH4jU0reJvYrPYDiX5QeptCvtAP+sVraW5TWEY8pXbLV0tr2jLq9i4gLlNp2Q6X13XxJxytd7vbjUaa9V6lf7qAUcC5RegBAVyLie0pnBN9l+0Tb7uU2NSKuVXqY0r2SvqZ0APirkl6qsZ1NBZ5UPPaHNwEAAADAutfkt3YDAAAAAEENAAAAmsF2p1cOjDbd7rYHC6eZbfvDhdN0eg/TopJ8Sk1ku9je0fabK9/3sT3p7vEiqAEAAAAmUES8Zl3XYRx2VHpAiCQpIs4f4xMKJxRBDQAAABoln2FYaPsc27faPjO/5FW2X2l7ke0bbC+2vXFt2tXOwNj+me2t8ueP2b7N9iVKDx9ppXmB7Xm2f2r7StsvysO3tv1j20tsf3qE+j4wWr1r6bexfUmeh2tz+RvZXpC/32S77dNzbf9zHn+D7ePysIW2d86fN7O9tM10r8rtdl3+v11+EuGnJB1k+3rbB9melZ8GKNtb5jrdmP8/Pw8/1fbXcj6/sn1gHv5s21fkvH5mu9N78Yqti0c6AwAAAOP1ckkvUXoJ6lWSXmt7saSzJR0UEUvyY++7eseQ7Z2U3uf1cqV95GuVnuYopZdWvzsi7nB6v+J/KL1s9quSvh4Rp+dHko+p3kqPTq86U+ndY+c6vdh4PaWngu6fH2W/maSrbZ9ffded0zsT95P06oh4yPamXdZJSq8G2DUiHrO9l6TPRMRbbR8jaeeIeH8uY1ZlmhMknR4Rp9k+XOnJffvlcc9Wetrni5SeWnmO0hMs50fEsU7vaHua1pKioGaTjTeILTbv/p1WM2eWv0pjaGi4KH1pGaX5S9LK5ZsVpZ82Y9noiWomej56sSx+eef9yyJi8+KCxmjG+k+JDTfYqOv0fWNog+HCNigtYzL2Fam8z090O5WWMfzQ0GMr47H1iwsZo6nQF0vznypl9GJZ/OGhe1k3ToG+0osyplJ//Ms9nxf33vdI8XQ/vX7ZzUrvf2o5KSJO6pB8cUTcJUm2r1d6p9qwpHsiYokkRcT9eXw3xb9e0rmtd6TZPj//30jp1RzfreTTes/ha5VeJC2lR8p/roty2tX7iaAmn1l6bkScm+fhkTx8fUmfsb2r0jvknqv0Hqfqux73kvTt1jxExH3dzHjWJ+k029tKCqX3To1mF6WXmktp/o+vjDsvPxb+FtvPzMOWSPpWnpfzImKtPXa/KKjZYvOn6kuf2aXr9AMDA8UVGhwsuoeruIzS/CVp+I4jitL3bXtKcRkTPR+9WBb7/vX8XxcXMg4bbrCR3rh99+8q7B9DG8wtbIPSMiZjX5HK+/xEt1NpGect/u/lo6dae6ZCXyzNf6qU0Ytlcfbi01k3ToG+0osyplJ/vPe+R7T40gNGT1gzbdOTHomInbtMXl3Xr1Tar7XSDvlIHtPqt2A8pfK53bTrSRqKiB075Ff6fpR29a7qFIEdqvTS+p3yC4mXavW6t6ZtV5/qPNenafm0pMsiYv98Od7CDulGUi27Op+WpIi4Igdl/ZLOsP35iDh9DOWsgXtqAAAAMFXcKuk5tl8ppbMetutBw1JJr8jjXyFp6zz8Ckn7235qPlvyFumJsz132n5bnsa2d8jTXKV0yZqUgo5xy+XdZXu/XN4M209TOpPyuxzQ7CFpyzaTXyTp8JxelcvPlmrVy2gP7FB0n9LLySVpVmX4HyVtvEbqZJFWn//6ZXSrsb1lnoeTlV48/oqR0pcgqAEAAMCUEBGPSjpI0r/bvkHSxVrzzMT3JG2aL/16j6Tb87TXKt2Pc31Oc2VlmkMlHZHzvFlS6yb9D0h6n+0lSkHB2nKYpKNs36gUODxL6T6bnW1fk+tza32iiJindP/KNXn+Wg9E+IKk9zg9WrrTNebHS/qs7askTasMv0zSn7UeFFCb5ihJ78j1PEypPUayu6TrbV+ndNneV0dJ3zUeFAAAAIBGiIiN8v+Fqlwe1bqJPX9eIunPa5M+kT4iHpb0xg75Hyvp2DbD75S0d4fh1Xsz2j7quJt619LfofQggrq294G08s+fj6vXIyJulfSyyqCP1+sTET+W9MJKmqPz8PskvbJW5Kl53NJ29YyIWe3qFxGnSTqt3TyMF2dqAAAAADQaQQ0AAACARiOoAQAAANBoBDUAAAAAGo2gBgAAAECjEdQAAAAAaDSCGgAAAACNVvSempkz+zQwMNB1+sHBweIKleQ/ljJK85ekQ/YsK2POgvIyJno+erEspPnFZYxH38w+9RfUce4Y2qAk/7GUMRn7ilTe5ye6nUrLWHj7RcX5j8dU6Iul+U+VMnqxLM5efHpxGeNBf2xuGVOxPwK9wpkaAAAAAI1GUAMAAACg0QhqAAAAADQaQQ0AAACARiOoAQAAANBoBDUAAAAAGo2gBgAAAECjEdQAAAAAaDSCGgAAAACNRlADAAAAoNEIagAAAAA0GkENAAAAgEabXpJ4aGhYg4ODXacfGBgorlBJ/mMpozR/SeofOKKwjFOKy5jo+ejFsui14aFhzS2oY/8Y2qAk/7GUMRn7ilTe5ye6nUrLGBoaKs5/PKZCXyzNf6qU0Ytl0Wv0x+aWMRX7I9ArnKkBAAAA0GgENQAAAAAajaAGAAAAQKMR1AAAAABoNIIaAAAAAI1GUAMAAACg0QhqAAAAADQaQQ0AAACARiOoAQAAANBoBDUAAAAAGo2gBgAAAECjTS9JPHNmnwYGBrpOPzg4WFyhkvwl6ZA9lxSl7x84oii9JM0tnI+xlHHInmVlzFlQ1k69WBbS/OIyxqNvZp/6C+pYuhwlFeU/ljJ60Vd60+cntp1Ky1h4+0XF+Y/H1OiLpb/3qVFGL5bF2YtPLy5jPOiPzS1jKvZHoFc4UwMAAACg0QhqAAAAADQaQQ0AAACARiOoAQAAANBoBDUAAAAAGo2gBgAAAECjEdQAAAAAaDSCGgAAAACNRlADAAAAoNEIagAAAAA0GkENAAAAgEabXpJ4aGhYg4ODXacfGBgorlBJ/pLUP3BEUfq5hfmnMsrmoxdlDA6eUpS+F8ui14aHhovaurSNpfJlORn7ymQsY6KXxdDQUHH+4zFtxjL1bdv9b3LOgrH8Hst+80/WdWPJcpB6syx6jXVjc8voxbIApirO1AAAAABoNIIaAAAAAI1GUAMAAACg0QhqAAAAADQaQQ0AAACARiOoAQAAANBoBDUAAAAAGo2gBgAAAECjEdQAAAAAaDSCGgAAAACNRlADAAAAoNEIagAAAAA02vSSxCuXb6bhO47oOv0hew4WV6h/oPv8JWnuYFkZ/QMDReknbxll7dSLZSHNLy5jPPpm9hW1dWkbS+XLcnL2lclXxkQvi4W3X1Sc/3jMnNmngYL6DY5h/kvyl8p/85Oxn4yljDkLysroxbJg3Tg5+8pkLKMXy+LsxacXlwE0AWdqAAAAADQaQQ0AAACARiOoAQAAANBoBDUAAAAAGq3oQQEAAADAaB55cLluW/yLdV0NPIkQ1AAAAGCtuu93m2jOiX8xhikvXet1wZMDl58BAAAAaDSCGgAAAACNRlADAAAAoNEIagAAAAA0GkENAAAAgEYrevrZtBnL1LftKV2nn7NgoLhCg4Pd5y9J/QNHFKWfOzhYlD6VUTYfvSijZDlIvVkWvTY8NFzU1qVtLJUvy8nYVyZjGRO9LIaGhorzH4+hoWENFtRvYAzzX5K/9ORdN5aut3qxLHqNbXVzy+jFdgqYqjhTAwAAAKDRCGoAAAAANBpBDQAAAIBGI6gBAAAA0GgENQAAAAAajaAGAAAAQKMR1AAAAABoNIIaAAAAAI1GUAMAAACg0QhqAAAAADQaQQ0AAACARiOoAQAAANBo00sSz5zZp4GBga7TDw4OFleoJH9JOmTPsjL6C/OXpLmF89GLMuYsKCujF8tCml9cxnj0zewrauvSNpbKl+Vk7CuTsYyJXhYLb7+oOP/xWLl8Mw3fcUTX6UvXW5LUP9B9/tLU6CdjK6OsnXqxLHq9bmRb3dwyerGdOnvx6cVlAE3AmRoAAAAAjUZQAwAAAKDRCGoAAAAANBpBDQAAAIBGI6gBAAAA0GgENQAAAAAajaAGAAAAQKMR1AAAAABoNIIaAAAAAI1GUAMAAACg0QhqAAAAADTa9JLEQ0PDGhwc7Dr9wMBAcYVK8pekOQvKyhgcPKUovST1DxxRlL5v2/IyyuejrJ16sSx6bXhoWHML6tg/hjYoyX8sZfSmr0x8n5/odiotY2hoqDj/8ZgKfbE0/6lSRi+WRa+xre4O/RGYWjhTAwAAAKDRCGoAAAAANBpBDQAAAIBGI6gBAAAA0GgENQAAAAAajaAGAAAAQKMR1AAAAABoNIIaAAAAAI1GUAMAAACg0QhqAAAAADQaQQ0AAACARpteknjmzD4NDAx0nX5wcLC4QiX5j6WM0vwl6ZA9y8qYs6C8jImej14sC2l+cRnj0TezT/0FdZw7hjYoyX8sZUzGviKV9/mJbqfSMhbeflFx/uMxFfpiaf5TpYxeLIuzF59eXMZ4sK3uDv0RmFo4UwMAAACg0QhqAAAAADQaQQ0AAACARiOoAQAAANBoBDUAAAAAGo2gBgAAAECjEdQAAAAAaDSCGgAAAACNRlADAAAAoNEIagAAAAA0GkENAAAAgEYjqAEAAADQaNNLEg8NDWtwcLDr9AMDA8UVKsl/LGWU5i9J/QNHFJZxSnEZEz0fvVgWvTY8NKy5BXXsH0MblOQ/ljImY1+Ryvv8RLdTaRlDQ0PF+Y/HVOiLpflPlTJ6sSx6jW11d+iPwNTCmRoAAAAAjUZQAwAAAKDRCGoAAAAANBpBDQAAAIBGI6gBAAAA0GgENQAAAAAajaAGAAAAQKMR1AAAAKARbK+0fX3l7yNjyGOW7RMKpznV9oEF6bey/bMO4z5v+2bbny+pw0Sz/cAYp9vd9ogvTLK9o+03V77vM5ZlN5Kil28CAAAA69DDEbHjuq7EOL1L0uYRsbw60Pb0iHhsHdVpou0oaWdJF0hSRJwv6fy1WQBnagAAANBYtvts32Z7u/z9LNvvzJ/3tn2t7RtsL2gz7WpnYFpnK5ycYPsW23MlbVHf3EB0AAAEwUlEQVRJs5Pty23/1PZ828+uDL/B9o8lva9DXc+XtKGkn9g+KJf/JduXSfqc7U1tn2f7RttX235Znm627dNsX2R7qe0DbB9v+ybb82yv36asbWxfkut0re0X2N7I9oL8/Sbb+3ao5z/n8TfYPi4PW2h75/x5M9tL20z3KtuLbF+X/29newNJn5J0UD67dlD1bJntLXOdbsz/n19ZNl/L+fxqtDNlBDUAAABoiqfWLj87KCKGJb1f0qm2D5b09Ig42fbmkk6W9NaI2EHS2wrK2V/SdpJeKumdkl4jSTl4+HdJB0bETpK+JenYPM23JR0VEbt0yjQi9lE+2xQRZ+fBL5S0V0T8o6RPSrouIl4m6V8lnV6Z/AWS+iXtK+k7ki6LiJdKejgPrztT0ol53l8j6R5Jj0jaPyJeIWkPSV+07epEtt8kaT9Jr87THj9iS63uVkm7RsTLJR0j6TMR8Wj+fHZtvltOkHR6nuczJX2tMu7Zkl4naUDScSMV7Ijoupa2fy/p111PgCebLSNi814VRn/ECOiLmEzoj5hMetIfbc+TtNkYJn2K0o53y0kRcVIl3wciYqMOZZ4k6a2SdoiIu2y/RdLBEXFoLd0sSTtHxPttnyppMCLOqeZv+yuSboyIb+Xh35c0R2mnfZGkX+XspikFC2+TdFNEtM4yvEzSnIjYvk09n5iHXP5lEXFa/n6dUhD2q/z9fyVtL+lDklZExLG211MKZJ4SEWH7U5Lui4ivVMrYWNLPI+JPamWvL+nLknaV9LhS4LZ1RPy2Mu9flHRrRJxcm3ahpA9HxDW2N5N0TURsZXv3PHzA9vOUgpJtJYWk9SPiRdU2b7MMlkl6dkSsyPW7JyI2y21zcUScmaf5Y0RsXG/PlqJ7anq5UgZGQ3/EZEFfxGRCf8RkEBF797K8vKP/YqWd/U0l3SXJSjvWI3lM+cqlfMZig8q4dtNa0s31szG2Z3ZRVicP1vKva+W7XJIi4nHbK2LVmYnHteY+fbt8JOlQSZtL2ikHEUuVAsn6tO3m5Ym2ajNNy6eVgrT9bW8laWGHdCOpll2976jTPEni8jMAAAA034ck/VzSX0v6Vj7i/2NJu9neWpJsb9pmuqWSdsqf95XUujflCkkH256W75nZIw+/TdLmtnfJea5v+yURMSRp2PbrcrrVzg4VuKI1bT4Dsiwi7i/NJE9zl+39cl4zbD9NUp+k3+WAZg9JW7aZ/CJJh+f01XZbqlVt1en+lj5Jv8mfZ1WG/1FSp7MsiyQdnD8fKulHneesM4IaAAAANEX9nprjbL9Q0pGS/jEirlQKDD4eEb+X9HeSvm/7Bkn1ezmkdM/NbrYXS3q1Vp01OVfSHZJukvR1SZdLUr4/5EClm/pvkHS98v02kt4h6USnBwU8PMb5my1pZ9s3Kt1D8vYx5iNJh0k6Kue1SNKzlO5Z2dn2NUoBxK31iSJintKTya6xfb2kD+dRX5D0HtuL1PnSwuMlfdb2VUqX5rVcJunPWvdB1aY5StI7cj0Pk/SB8lktvKcGAAAAACYbztQAAAAAaDSCGgAAAACNRlADAAAAoNEIagAAAAA0GkENAAAAgEYjqAEAAADQaAQ1AAAAABqNoAYAAABAo/0/y27RSN54eMsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x180 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# it is important to demonstrate filters here \n",
    "# consider moving plotting code elsewhere or simplify it significantly ...\n",
    "# split cell above and demonstrate kernels - it's nice:\n",
    "def draw_kernel(kernel,\n",
    "                axis,\n",
    "                cmap='viridis'):\n",
    "    # kernel:\n",
    "    imk = axis.imshow(\n",
    "                    kernel[::-1,::-1],\n",
    "                    alpha=0.7,\n",
    "                    cmap=cmap,\n",
    "                    interpolation='nearest')\n",
    "    # clean axis:\n",
    "    axis.set_xticks([])\n",
    "    axis.set_yticks([])\n",
    "    axis.set_xticklabels('',visible=False)\n",
    "    axis.set_yticklabels('',visible=False)\n",
    "    axis.set_title(\"{} kernel\".format(ktype),fontsize=16)\n",
    "    # add a checkerboard to highlight pixels:\n",
    "    checkerboard = np.add.outer(range(kernel.shape[0]),\n",
    "                                range(kernel.shape[1])) % 2\n",
    "    # show it:\n",
    "    axis.imshow(checkerboard,\n",
    "            cmap='gray',\n",
    "            interpolation='nearest',\n",
    "            alpha=0.3)\n",
    "    #\n",
    "    return imk\n",
    "\n",
    "fig = plt.figure(figsize=(12,2.5))\n",
    "gs = plt.GridSpec(nrows=1,\n",
    "            ncols=5,\n",
    "            figure=fig,\n",
    "            width_ratios=[1,1,1,1,0.1])\n",
    "\n",
    "for i,ktype in enumerate(ktypes):\n",
    "    kernel= kernels[ktype]\n",
    "    ax = plt.subplot(gs[i])\n",
    "    draw_kernel(kernel,ax)\n",
    "    \n",
    "# colorbar and that's it:\n",
    "ax = plt.subplot(gs[i+1])\n",
    "cb = fig.colorbar(imk, cax=ax)\n",
    "cb.ax.get_yaxis().set_major_locator(ticker.MaxNLocator(1))\n",
    "cb.ax.set_yticklabels(['Excluded from calculation','Included in calculations'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a little remark on the `lowleft` kernel:\n",
    " - by the definition of convolution, it implies integrating f(x)*g(-x) ...\n",
    " - in other words the kernel is being \"flipped\" when it is applied to a matrix\n",
    " - we should try to make it explicit or hide it away on a better way"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Getting to the calculations of locally-adjusted expected**\n",
    "\n",
    " - for demonstration and debugging purposes we are going to dump the dataframe with locally adjusted expected right in place (i.e. in memory).\n",
    " - This might be also ok for smaller genomes and potentially for small subsets of large genomes.\n",
    " - This is not recommended whatsoever for genome-wide dot-calling.\n",
    "\n",
    "A side note, we've tried to store all of the values in a separate file,\n",
    "but practice shows that for large genomes even parquet/hdf5 are not fast enough.\n",
    "Thus using a **2-pass** strategy seems to be the best option indeed.\n",
    "\n",
    "**2-pass**: calculate locally-adjusted expected for each pixel and use this value *immediately* to build a histogram with predefined bins, then recalculate locally-adjusted expected values and again use them *in place* to select significantly enriched pixels.\n",
    "\n",
    "\n",
    " - an example on how to store locally adjusted expected in a temporary file:\n",
    "```python\n",
    "import tempfile\n",
    "tmp_scores = tempfile.NamedTemporaryFile(\n",
    "    suffix='.parquet',\n",
    "    delete= False,\n",
    "    dir='.')\n",
    "```\n",
    " - now calculate locally adjusted expected (not performed in the call-dots command line implementation):\n",
    "```python\n",
    "loc_adj_exp = dotfinder.scoring_step(clr,\n",
    "                    expected,\n",
    "                    expected_name,\n",
    "                    \"weight\",\n",
    "                    tiles,\n",
    "                    kernels,\n",
    "                    max_nans_tolerated,\n",
    "                    loci_separation_bins,\n",
    "                    tmp_scores,\n",
    "                    nproc,\n",
    "                    score_dump_mode,\n",
    "                    verbose)\n",
    "```\n",
    " - histogramming using temporary input (this steps is performed in actual call-dots implementation and it involves de novo calculation of locally adjusted expected for each surveyed pixel):\n",
    "```python\n",
    "gw_hist = dotfinder.histogramming_step(tmp_scores,\n",
    "                                    score_dump_mode,\n",
    "                                    kernels,\n",
    "                                    ledges,\n",
    "                                    output_path=None,\n",
    "                                    nproc=1,\n",
    "                                    verbose=False)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Preparing to convolve 49 tiles:\n",
      "creating a Pool of 8 workers to tackle 49 tiles\n",
      "returning local copy of the dataframe ...\n"
     ]
    }
   ],
   "source": [
    "# locally adjusted returned in place for just 1 chromosome:\n",
    "# beware: this step is not performed in the actual call-dots CLI implementation\n",
    "la_exp = dotfinder.scoring_step(clr,\n",
    "                    expected,\n",
    "                    expected_name,\n",
    "                    balancing_weight_name,\n",
    "                    tiles,\n",
    "                    kernels,\n",
    "                    1,\n",
    "                    loci_separation_bins,\n",
    "                    None,\n",
    "                    nproc,\n",
    "                    \"local\",\n",
    "                    verbose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**that is how locally adjusted expected dataframe looks like:**\n",
    "\n",
    "bin1_id|bin2_id|count|la_exp.donut.value|la_exp.vertical.value|la_exp.horizontal.value|la_exp.lowleft.value\n",
    "---|---|---|---|---|---|---\n",
    "76|87|20|16.343724585366036|19.112339277607475|14.789222300465001|17.55971648783403\n",
    "76|88|29|21.109446293886823|23.76004284738352|19.119195822013385|23.30209962326733\n",
    "76|89|15|17.254427190306977|18.545853810657224|14.695003640984938|19.784933947834944\n",
    "76|90|21|14.277047600786759|14.642767228999286|12.928217571836717|17.27371365389384\n",
    "76|91|13|11.22588212884422|11.279966641429564|10.064704945467405|14.514049136987758\n",
    "\n",
    " - here we use `cooler`-based `bin1/2_id` instead of actual genomic coordinates for compactness and performance reasons.\n",
    " - Observed is recorded in the `count` columns, again as in the parent `cooler`-file.\n",
    " - observer and all types of expected are expressed in the raw units in order to apply Poisson statistics to the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Observed vs \"locally-adjusted\" expected\n",
    "\n",
    "A scatter plot with observed vs expected should be a good \"platform\" for understanding what a dot-calling is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def quick_obs_exp_scatter(data,\n",
    "                          axis,\n",
    "                          xlabel='la_exp.donut.value',\n",
    "                          ylabel='count'):\n",
    "    # obs exp\n",
    "    # the base scatter:\n",
    "    sct = axis.scatter(data[xlabel],\n",
    "                      data[ylabel],\n",
    "                      # color dots on the scatter by their genomic separation\n",
    "                      c=data['bin2_id']-data['bin1_id'],\n",
    "                      vmin=0,\n",
    "                      vmax = 100,\n",
    "                      cmap=\"YlOrRd_r\")\n",
    "    # we can add a visual of the lambda-chunking grid on top of obs/exp scatter ...\n",
    "    # plt.vlines(ledges[1:-15],ymin=0.5,ymax=900,color='red')\n",
    "    axis.set_xscale('log')\n",
    "    axis.set_yscale('log')\n",
    "    # limits\n",
    "    axis.set_xlim(0.5,700)\n",
    "    axis.set_ylim(0.5,1200)\n",
    "    # labels\n",
    "    axis.set_ylabel(ylabel)\n",
    "    axis.set_xlabel(xlabel)\n",
    "    # return axes\n",
    "    return sct\n",
    "\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(7,5))\n",
    "gs = plt.GridSpec(nrows=1,\n",
    "            ncols=2,\n",
    "            figure=fig,\n",
    "            width_ratios=[1,0.1])\n",
    "\n",
    "# we might consider \"downsampling\" la_exp dataframe in order to make obs/exp scatter plot less busy:\n",
    "data = la_exp.sample(frac=0.1)\n",
    "ax = plt.subplot(gs[0])\n",
    "sct = quick_obs_exp_scatter(data,ax)\n",
    "\n",
    "\n",
    "# y=x line to highlight the \"enriched\" pixels ...\n",
    "ax.plot(ax.get_xlim(),ax.get_ylim(),'b-',label='obs=exp')\n",
    "ax.legend(loc='best')\n",
    "\n",
    "# cbar\n",
    "cb = plt.colorbar(sct,cax=plt.subplot(gs[1]))\n",
    "cb.ax.get_yaxis().set_major_locator(ticker.MaxNLocator(1))\n",
    "# cb.ax.set_yticklabels(['Excluded from calculation','Included in calculations'])\n",
    "\n",
    "# enriched = data[data[ylabel]/data[xlabel]>1]\n",
    "# ax.scatter(enriched[xlabel],\n",
    "#             enriched[ylabel],\n",
    "#             s=80,\n",
    "#             facecolors='none',\n",
    "#             edgecolors='b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obs vs exp scatter plot highlights the enriched pixels:\n",
    " - pixels that are above the blue line `obs=exp` are all \"enriched\", i.e. for all of them `obs` is more than `exp`.\n",
    " - Problem is, such a naive way of extracting enriched interactions yields too many false positives\n",
    " - should we show a heatmap of all of such \"enriched\" pixels - to demonstrate that it's not so good ?!\n",
    " - we need to do more rigorous statistical analysis to extract \"significantly\" enriched pixels instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Now let's load in, some known called/annotated dots to see where they end up on the obs/exp scatter-plot**\n",
    "\n",
    "we would use this pre-called dots to see them on our obs/exp scatter plot, later"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let us read in some of the known dots to display stronger ones on the obs/exp scatter plot:\n",
    "raodots = pd.read_csv(RAOLOOPS,sep='\\t')\n",
    "# beware of the UCSC/NCBI chromosome naming conventions `X` vs `chrX` ...\n",
    "raodots_chr1 = raodots[raodots['chr1']=='1']\n",
    "\n",
    "# do we need a notion of strength here ?\n",
    "# #let's quickly define some measure of strengths for the dots:\n",
    "# raodots_chr1['strength'] = raodots_chr1['o']/raodots_chr1['e_donut']\n",
    "# # now sort and select only the strongest (according to this measure):\n",
    "# raodots_chr1_strong = raodots_chr1.sort_values(by=['o','strength'],ascending=False)\n",
    "\n",
    "# let's convert genomic coordinates into `cooler`-based bin_id-s:\n",
    "bin1_ids = (raodots_chr1['x1']/binsize).astype('int')\n",
    "bin2_ids = (raodots_chr1['y1']/binsize).astype('int')\n",
    "# beware Rao et al, use x1,x2 for start1,end1 and y1,y2 for start2,end2\n",
    "\n",
    "# now let's look up these called/annotated dots in our pre-calculated la_exp dataframe:\n",
    "rao_dots_idxs = list(zip(bin1_ids,bin2_ids))\n",
    "la_exp_indexed = la_exp.set_index(['bin1_id','bin2_id'])\n",
    "\n",
    "# these are the rao-dots that we have caculated locally adjusted expected for:\n",
    "intersect_raodots = la_exp_indexed[la_exp_indexed.index.isin(rao_dots_idxs)]\n",
    "# we don't have for every rao-dot since we don't get close enough to diagonal and\n",
    "# potentially treat NaNs differently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extracting statistically significant interactions\n",
    "\n",
    "**starting from here it requires more cleaning/trimming down ...**\n",
    "\n",
    "\n",
    "So how could one extract significantly enriched interactions instead of calling every marginally brighter pixel \"enriched\" ?\n",
    "\n",
    "We have our *null* hypothesis: intensity of a HiC pixel is Poisson-distributed with a certain expected. In this case that would be *locally-adjusted expected*.\n",
    "\n",
    "Thus for the dot-calling, we could estimate a *p*-value for every pixel based on its observed intensity and its expected intensity:\n",
    "```python\n",
    "from scipy.stats import poisson\n",
    "\n",
    "for k in ktypes:\n",
    "    la_exp[\"la_exp.\"+k+\".pval\"] = 1.0 - \\\n",
    "            poisson.cdf(la_exp[\"count\"],\n",
    "                        la_exp[\"la_exp.\"+k+\".value\"])\n",
    "```\n",
    "\n",
    "However going that route would be technically challenging for the further genome-wide calculations, so we can introduce the *lambda*-chunking procedure introduced in Rao et al 2014 to tackle technicall challenges and some issues associated with the wide dynamic range of the expected for the dot-calling (due to distance decay)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**should we keep in some form or go straight to Rao procedure ?!**\n",
    "\n",
    "**now let's select pixels that are \"significantly\" brighter than their surroundings ...**\n",
    "\n",
    "Just use *naive* p-value thresholding for simplicity and quick turn around.\n",
    "\n",
    "And then see where such \"bright\" pixels end up on the obs/exp scatter plot depending on the p-value threshold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# arbitrary p-value threshold\n",
    "p_th = 0.0001\n",
    "\n",
    "# let's test p-value for all of the 4 filters - feel free to play with individual filters/kernels as well:\n",
    "signif_pvals = np.ones_like(la_exp[\"la_exp.donut.pval\"].values,dtype=np.bool)\n",
    "for k in ktypes:\n",
    "    signif_pvals = signif_pvals & (la_exp[\"la_exp.\"+k+\".pval\"]<=p_th)\n",
    "\n",
    "\n",
    "# plotting - consider making it shorter:\n",
    "sct = plt.scatter(sub_la_exp[xlabel],\n",
    "                  sub_la_exp[ylabel],\n",
    "                  # color dots on the scatter by their genomic separation\n",
    "                  c=sub_la_exp['bin2_id']-sub_la_exp['bin1_id'],\n",
    "                  vmin=0,\n",
    "                  vmax = 100,\n",
    "                  cmap=\"YlOrRd_r\")\n",
    "\n",
    "# let's select pixels with \"small\" p-values:\n",
    "kinda_signif_pixels = la_exp[signif_pvals]\n",
    "\n",
    "plt.scatter(kinda_signif_pixels[xlabel],\n",
    "            kinda_signif_pixels[ylabel],\n",
    "            s=80,\n",
    "            facecolors='none',\n",
    "            edgecolors='b')\n",
    "\n",
    "# we can add a visual of the lambda-chunking grid on top of obs/exp scatter ...\n",
    "# plt.vlines(ledges[1:-15],ymin=0.5,ymax=900,color='red')\n",
    "\n",
    "ax = plt.gca()\n",
    "fig = plt.gcf()\n",
    "\n",
    "ax.set_xscale('log')\n",
    "ax.set_yscale('log')\n",
    "\n",
    "ax.set_xlim(0.5,700)\n",
    "ax.set_ylim(0.5,1200)\n",
    "\n",
    "ax.set_ylabel(\"count\")\n",
    "ax.set_xlabel(\"la_exp value\")\n",
    "\n",
    "fig.colorbar(sct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Rao et al 2014 statistics is more nuanced**\n",
    "\n",
    " 1. Simple p-value thresholding should be replaced to more \"productive\" FDR, which is more tractable and better suited for the job.\n",
    " 2. Another argument is that it is \"unfair\" to treat all of the pixels with the same statitical testing (multiple hypothesis) - the range of \"expecteds\" is \"too wide\"\n",
    " 3. 2nd point is addressed by spliting the pixels in the groups by their localy adjusted expected - the so-called $\\lambda$-chunking\n",
    " 4. Another nuance of $\\lambda$-chunking is that Rao et al are using the upper boundary of each $\\lambda$-chunk as an expected for every pixel in the chunk (clearly for technical reasons) - we could see how that affects the significance by itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-100, 8500)"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The essence of lambda-chunking - let's split the surveyed pixels into \"chunks\" based on\n",
    "# their la-expected value and do multiple hypothesis testing separately for these chunks.\n",
    "nlchunks = dotfinder.HiCCUPS_W1_MAX_INDX\n",
    "base = 5 ** (1/3)\n",
    "ledges = np.concatenate((\n",
    "    [-np.inf],\n",
    "    np.logspace(0, nlchunks - 1, num=nlchunks, base=base, dtype=np.float),\n",
    "    [np.inf]))\n",
    "\n",
    "#################################################\n",
    "plt.plot(ledges,np.zeros_like(ledges),'r|')\n",
    "plt.title(\"the $\\lambda$-chunks\")\n",
    "plt.xlabel(\"# of interactions\")\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(6,1)\n",
    "ax = plt.gca()\n",
    "ax.set_yticks([])\n",
    "ax.set_xlim(-100,8500)\n",
    "\n",
    "# consider embedding this picture to the markdown section ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7f6c857a79b0>"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEPCAYAAAC5sYRSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsnXmYHFW5h9+vqnqbfclk30kIOwYSVpEIqOygKOAKqICIgop69eLFFfcLCigCItsVEFDZZJEtLAKBEEIIJJCNLMwkM5PZe6+q7/5xumfLhElCZulJvc9Tz0xXV5861TP9q69/5zvfEVUlICAgIGBkYQ11BwICAgICdj6BuAcEBASMQAJxDwgICBiBBOIeEBAQMAIJxD0gICBgBBKIe0BAQMAIJBD3gICAgCFARP4iIvUisrTbvioReUxEVuR+Vub2i4hcJSIrRWSJiBzQX/uBuAcEBAQMDTcDx/ba9z3gCVWdCTyRewxwHDAzt50HXNtf44G4BwQEBAwBqvoM0NRr9ynALbnfbwFO7bb/VjW8CFSIyLj3aj8Q94CAgIDhwxhVrQPI/Ryd2z8BWN/tuA25fVvFGZDuDRKjRo3SqVOnDnU3AgICCoBXXnmlUVVr3k8bxx57mDY2tmzDuZa9AaS67bpeVa9/H6eWPva9Z+2YYSPuIrIncDEwCuM59espTZ06lYULFw543wICAvqmpQX++ld46y0oLYXTToMD+h3qGxpEZO37baOxsYWFL9/a/7msuSlVnbMDp9gkIuNUtS5nu9Tn9m8AJnU7biJQ+14NDagt09docG7/sSLyVm7k93sAqrpMVb8CnA7syJsSEBAwiNxwA0ybBs89B9Ongwh8/ONw3HFG9EcmCvjbsO0w9wNn5X4/C7iv2/4v5LJmDgFa8/bN1hhoz/1meo0Gi4gN/AEz+rsX8GkR2Sv33MnAc5hR4oCAgGHKPffA5ZfDSy/BHXfAN74BP/sZrF5tBP8Tn4ARW3BWtf9tGxCRO4AXgFkiskFEvgT8EviIiKwAPpJ7DPAQsBpYCdwAfLW/9gfUllHVZ0Rkaq/dBwErVXU1gIjciRkJflNV7wfuF5F/AbcPZN8CAgJ2DFX40Y/gz3+GmTN7PmfbcM01sO++8MwzcOSRQ9LFAURBvZ3Tkuqnt/LU0X0cq8CF29P+UGTL9DnqKyLzckn612HuUn0iIueJyEIRWdjQ0DDQfQ0ICOjF0qWQSMDRW0iQwbLgS1+C20dseKbbsA09QzGg2ueor6rOB+b39+LciPP1AHPmzBke72JAwC5EUxNMmGA89q0xcSK88MLg9WnQUEDfl6c+aAyFuG/3qG9AQMDwYfJkkx2TTkMk0vcxS5bAiM1SLpDBhKGwZV4GZorINBEJA2diRoK3GRE5SUSub21tHZAO9mDePLMNt7aC9kZ2ezuxrfp6WDttHq+UzmPvveFTn4LHH39vjfJ9ePhhOOMMOOIIk+J4333gumbA9LHsPJr277t/ra1w443GmtlmhvPfogfbYskMD/Ef6FTILUaDVdUFvgY8CiwD7lLVN7anXVV9QFXPKy8v3/mdDggYQbz0Euy3H6RSsNsMuPNOOOoo+NrX4MtfNiLem3gcPvYx+O//hmOOMVkxJ55ofs6bZ9Icp0+H1atMpozXbXxxzRo44QT45Cdhjz0G7TIHF/X634YBA50t0+dosKo+xHsMmgYEBLx/2tvhlFNMPvqs/zX7KvY1mSwnngjHHgvnnmtSGMd1q1JywQXm8SOPmOwXgA99CM46y9wUzj4b7i2FffeDb1xhbgJz50Jjo7FjLr4YLr100C93kNDAcx9IROQk4KQZM2YMdVcCAoYt//d/cPjhcNJJQE7cOzrgW9+Cu+4ykfXtt8Pf/26E/uqrjY/+4IOwbl2XsOexLLjySuO5J6ZAWSm8PB9efbVrhuqHPwxFRYN9pYPN8LBd+qMgC4cFtkxAQP888ojxzPP4vpk9ms3CihXw4osmq+WRR8zPQw+F734X9twTtpZlHIkY/31zt1qGs2fDmWcaO2bkCzs7bRLTQFOQ4h4QENA/2SxEo12PN9Ubcb7xRqjJlc+KxcwA6JIl8O678PTTRtjnzoVTT+1b5MvLzY1CFf75TzMb9YMfhNNPh4ce6tvHH1kMaPmBnUYg7gEBI5S5c+Gxx7oe19UaS8bKfeo3bID16+ErXzEDpfPnm8HRSMTYMrNmmYlKHR09250/39w0Xl0Mv/41HHdwA987eRHzZjdx6aXG4onHB+kiB5ttidqHSeQeeO4BASOUc881mTI1NXDK69DeAXffDZMmwT77wI9/bMoH7LuvGRRVhU2boKrKWDW//KWxb266Cb7+ddPmY49BbS3Ud0BpiXJD5Tm0X/4yEg5Tlclw27FH88vQFXz1qza33PLe/StYhkk2TH8UZOQeeO4BAf2Tr8z4858rUTtLyPYJkeGoo4ygL1xohPrii81xGzeaQdG//AXOP9/UiDn3XGPjJBJw/fXw2c+aujLt7TBe19L23Mv4qTReWzuaStP+6JN8b9KfeOAB0/aIpEAi94IU94CAgPcmHofjj4crLtvMHyZ8h47GBFlXuPlmRVIJ6uuNcNfWmlICtbVGvM88Ew45BJ54wtgvZ54Jr78O48ebLJp//cv48DU14NY3oKl0j/P6yRTxW27huOPMJKiRx4CX/N1pFKQtExAQ8N7ccQfMnq0cdOsZpBvWMkM2kCZCVJPMSC2ldO+9ufTSSmzbpDZalvHWx441Pvvhh8Pvf29SHL/8ZXj5ZRg1yrRt8t8VfO0zPPTiCcrKTFrliGSYROb9UZCR+6CWHwgIKCB830TdV18Nk0qbaNnQDr5PQot4W/fEwmex+wEWvmrR0mLKCSSTRtjLy2HzZnj+eViwwPjxn/mM8eg3buw6x377QWurYJf0kfcoQtmHDmb+fGP9jEyC8gMDRuC5BwRsySOPwO67w3e+Y2aLvrgozHGN/+bM+P0s032w8TjR+SeT5B2aMmXYtvHYVY2F09RkxL2iAv79b9h7b2PBjBkDH/0ofP7zkMmYfPZUCtJjZ2CVFCEhYwBIJIxdVsLij/wc2zbpkSOP3AzV/rZhQGDLBASMAB5/3JQHuP12UzvmkksgJBHib69ghTcLAEV409+HlBRTU5qgoa240zp56CEzI1WkKzd+6VJTY6alBVatMnnsF10Ef/qTmd365rIoi3/0MB+uvwF/2VJ0/7k8Wnw2v768lAcffO+SwAWLUjDZMoG4BwQUOKomWv/zn41fXl9v/PH/+Z8wwh7U8C4gZAizxD8QHwttM8qbyUAoZCY8WZaxdZJJ067nmbTI22+Hww4zk5quuAIuuwzGVxrb5VcvVnLpM9+lpgbqXzQR/pNPmlTLEUuBeO6BuAcEFDiLF0NbmxH288+Hv/3NZLM4DriuzUYmYeETI8m/yo/m1NaHSRHDhKGC50E4bAS+O65r6s4AvPGGmcWqaiY8vTHa1Ja5/35j5TQ2wujRUFk5yBc/6AwfT70/CtJzDwZUAwK62LDBzCb91Kdg5Upjm9TXGxGuqICQo/hYJIlxett9ZAkBYIuxF2zbRPC2bQZRu9sp6bRSFWnjwT0+TVkozuFzkqxZA4sWdZUZqK425x/5wp4j8NwHDlV9AHhgzpw55w51XwIChop4HG6+2Uw6Wry4S2yffNL8fOopI9iOmpDcxyajDh42oPgqiCjZrGBZ5kbQ3q4Uh1J0ZKLkI9SidD3e64v4kPyDhQuP5GtnxUjfamazjtuiV7sChRG5F6S4BwTs6jz6KHz848Y6Uc0LuxEdQRGBbFbIZgXzMTcWjEuY/DLGinTqVN5rT8SVMCaid0jjEqWWqfyBy+jQEhqp4ZTl5xMJw/oNu6C4q4JfGAOqBWnLBATsyixZYgY3x40zVR1dF/IzJ/fgVRTB17y3opiPuXns5iyZvojHFUVIU5w71qTNhMjQzCie5iRKaKNp4TLKyo2Vs2sS5LkHBATsRNatg9/8xqQnplKwejW0tXUXE4vlzN6BlrvEyMHttt9EqGlirGYWEVLsy0v8Wq4kkwan12IeuwwFUlsmsGUCAoYhqTRsrIMffA6Ki82g6XPPmSg9kcgf1V1E8oN43eM1Y8VsG6Ytt4ckCA4ZimijhA7m8RCfj/6ZL4Xn09ICU6du92WNAPK1ZYY/BRm5B9kyASMVVbMQ9cKFJjXxYx+DV14xRbzicSP0fWEkvPfH+f3OIrJwCdNOFYeEn+Os8LXUfOoEvEgpCEyY+D6bL1QKJHIvSHEPyg8EjFRuuMFMGjporklLnDvXRO0f+xhMn959ZaSeAqID+lEW/mGdy6V7LuLwO39KR4dQUwM2Hi1PPk/Hq2+gw0TQBoUCEffAlgkIGCZ4Hvz852YSUse5pljXsR+FkhJTPnfLAcztsV22le4DsQA+gpJMCa+9brPHnqZwWOyxdtpeWM7y0y9EPZ/w+NHs/eBfiE6btJP7M9zQgik/UJCRe0DASGThQrPA9GWXmVou0ZiJ3qdONeVzt1ybdCCKt/SOOi3G8Q4R0nyQf7PvtFbu+ptS1rQKfB+vrQM/niC1ah1vnPjFXSSCL4xsmSByDwgYJrS3m2h9wwaIJyCxDp5av7Vv+cLAiYh2+ynUMxEfm1f8Q6ien6IyDMlUlFLpVrDd98nU1hNf/CYls/ceoH4NA5RhMwO1P4LIPSBgmPDcc9DcbErtzpjRtZB1b7qm+Q902UXTfpYIHg4dlFMfL2XPotU0MWrLo20bt6llgPs01AQLZAcEBLwHvm+WrLvhBnjtNZMZU1dnygUsXw4rcxrZl0w0N3d/NJARfE8El5qSBKmK8bQ2VeJpz0R3zWYpmbvfoPRlaBke4t0fgbgHBAwymQyccYZZwi4eNxF6e7t5zvO6FrbeOkMjLorN+vYqjj4hTmh1llom4/tZxBLsoghTLv8OTlnpkPRtUCkQW6YgxV1ETgJOmjFjxlB3JSBgu7nsMiPm63N+ejy+Pa8eyqhRsHC5/U6bH8k61up0WklRXgKz7vhfqj525BD2bbDQghH3gvTcgzz3gEKlqQl+9zuzzmlHRyEJuzm/h4ONS7G2ECbNWm86XjLN5keeG+K+DSIFUvK3IMU9IKAQcV0zGSmfr761AdPhiyD4VGBmUmnusaYzbLr9gSHu22Cyc1IhReSbIvKGiCwVkTtEJCoi00RkgYisEJG/iUh4R3tZcP9eAQHDkQ0bYPUaWLAAxo6FI46A227rWt0ok4FPf9qUEsgnU0QiQ9ffHSFKBzYe+/AKaaK4hJjCcvPkUH+pGCwUVLXfrT9EZAJwETBHVfcBbOBM4FfAlao6E2gGvrSjXQ3EPSDgfbJgARx4oCnzvffe8Oqr8O1vw/XXwwknmCXwTj7ZWDH5z30o1LVWqWH4TYLpiY+Lg4fDKdxKHVOopp4wWSQcYvQZxw91BwcJ3Zm2jAPERMQBioA64CjgntzztwCn7mhPA3EPCHgfJJNm0YwbbzS56SUlps76ySfDffeZQl8f/7iJ4LuvUWp+31Yx7+uYgchxf682BY8Qs1jMFfwKC4/R1OKEbGK7TWbaT78xAP0ZpmybuI8SkYXdtvN6NKH6LvBbYB1G1FuBV4AWVc3XXd4ATNjRbhZktkxAwHDhrrtg9mw48UTgtyYy/9O1cM01sHatsWOyWeOv9ywf8H6j84GI7rfWpmLh4+BSRAfH82cmsxILpWRsOQe+dj+Ws6tIyTZnyzSq6pytPSkilcApwDSgBbgbOK7vE+4Yu8pfJCBgQHjoIWPFvPgiHOSbVZL+e4mJ6DOZLhtm68Le3ySkobNoBB8Ln+ks4wRu5zjuw7FcBHDULOVXMmPSLiTseXbK3+QYYI2qNgCIyD+Aw4AKEXFy0ftEoHZHT7Cr/VUCAnYKdXVwySVw770wZQo8/jj8brER819fD488YmwZr98CggMr3hY+EUy+5SRW84jsz+NyMhv9sUyPrufw0H8YI3W87B/KJm8sxbQzPrmYUprpfuMJA8URD0sEEZA0iAhjv7kLrlG/c8oLrAMOEZEiIAkcDSwEngI+CdwJnAXct6MnCMQ9IGA7qa832TCnn24W1liwAM45B/RECIfNJKWNG4e6lwYfiyTF2LikiVHiJDmVv6EWVEWzSM5mP9x+jvzyql4Y1rd2ZeBFLZ+KmI+vgt9N2KyiGJUnfWQwL2foUXaKuKvqAhG5B1gEuMCrwPXAv4A7ReRnuX037ug5AnEPCNhOfvpTkwXz85+bTJhf/tKsb/orNbVh4nEQGTb1owALD4dmqnnCn8NR8jAi4HpCyNmyk76ClRtcVUyE7qsQDfv4ubpYtmcRnjB2kK9jOLDzltlT1R8CP+y1ezVw0M5oPxD3gIDtIJWCv/7VROu33WbSHo85xiywAUYY83ViejK0Si8oFTRxq3cBr1qHcIn1Q+JpmzLbeOjdb0bpjEXE9sl4Jpku4wlqW4CPJSDRMKJhnJrqIbueIWWYzEDtj4IU96C2TMBQUV9vfu63X1dqY3dfPZXq61WDJexbH5xVhAmynuucM/hK9k6ekBM42v8XzR2O8dItpSNjkXZtLCBsKZ6veGrazI6bQuWEYjSRpOzU44n96+9I4U2x3TkUiLgX5F8nqC0TMFT87/+akruplBF1z4P99x+ss/eX2/7eNxEPm2IrwZecq7nH+7wxGNSiNRmitj1MW9oh7VkkPaEta+FYeRET2t5ez6qnlvPuuylSpTXGf9olKZx67gUp7gEBQ8HPfw5XXWVy1ktLwXEgGjX12AeH9yca7+pkAA6Xp1jG/oytTFMSzaKihKRneqYCab9rPVXJbVpXxzvf+gmtLyyiY9kqOpatel99KkwKY5m9QNwDAraBRYvg0kvN70ceaQLXsjK48ML+XrmzP+g7OjNVaaXCBJW5FJn6lgipjE3YgqgNJY7mZN2cx1gyhojtURL2idhKWDwkm8VraOQ/ex3Hm9+4/H1dUcERVIUMCBgZuC58qVv5pmefNeV6m5qMTTO47MjNQrFQFIv2jMV/5BhmWy8BiuZuFiLmthGxtdcrlapSD8fK5bfn9D4v+xFbWX/VbbS8vGRHL6iwyKdCBrZMQMDwpr0dfvtb+M1v4Pnnt/xcPvUU7LYbLF4M+a/cRUUmz72030WHhsOH3CxyLfg4ZGmlgj+kv8Fpciu9vwWIQKjXFwPbVpIZwe/jUgQIWUbM3vn9bQN1AcMMNRXi+tuGAYG4B+ySrF0Li16FN94w5Xrr6uDss2HOHLP8HZiSAqeeCntO6wCUiJ3GEp9E3GX+fN1KyiMMnO/anyXT1/M+Dmk8bIro4GLu5oM8yhHW49t0vqwnJNL9y4Sf7DNNaGRSIJF7QaZCBgRsL0uXwptvQlGRSWP88Ifh6VEwcSIc8jtzTD6CnzvXROuvvw6RsM+il9NAMWkvAiji5z+/PkZQt3WR6ve7mPW2VI/sjodZ1toUjvexuYgfMpsXENHcNXTdEFQhsxW72LItVP1OWyZ/towniCVM+MIp23cphcwwEe/+CMQ9YESzZAlccIGJ1A85xKQxvvCCKc87sZIeYvXgg0bcJ0/2WfG24nkWiaSQoKrzGMHHUzv3e15Ot/XDPtiiYGPhMZtn2ZtF2HjMJgko4ZCP51p4ft5GNtZLV4ZMF2NOOILdf/M93jj607jNreBrp/WcRSifdxCjTzpqkK9tiNBtrgo55ATiHjBiefNN+MhH4Be/gC98waQughH2SMTYL3vsYfa99RZ88YtwximbufOuMPFESZ9tKna33weipnoXNi7zJiygLl5NIhWmLFVLMW2kKCFEljnRJcxxXmKptx+vJPellBYO4D8I8A6zGMN6DuAFqtmETZcP7CM0xh0cUWKOdDoJ8S2sYsVyHPb755+wQiEOXPMfmh58gsYHnkT+fjPiOOx74zWMPfWYXWtCUxC5BwQMLZdeCt//vhHt7jQ1wZNPwru7Q2sr/Ot2+O53oaVZufden45kroIWiiWKr0MjXHs4y7h973Op2TOMRG3a25RXb2hFXWVcZZZY2Mfz4cM8S73v0JG2O284R/BY5zV0jzP9zu8aFq4qrq94ClkfYrb5PW/NhG2l5piDsELm/bAiEUaddjyjTjse3lkIQNknPjoYb8UwQrel1OewIBD3gBFJfT08/bSp/9KbcePg7bdhdLGZgHTJJbBpk7FZ6lsqcf18dD6wkXl/pP0wzQs6qH3VYZ//Hk/JRCFc2kGmxSeVtYg4ppBXY1uIVNbCFkAVH8mNBihh2ydkgZU1ol7q+KQ8IasmzTHlCY4oRY4StpVo2EfV1MjxfZj5h58M6Xsw7NhJVSEHg13ou1TArsT69abOekkf7sqee8Jxx0FLi/msbt5sPq9HHlTPHhM39DjWV4iG0oPT6V6s9HfnLW8vwmmXBd+vZcUdzdiuR3mVksg6KNDS4RB2fEaVZimPudgW2KKELJ9YyCdkK1kvf5MyE5Mc6XrsAxkVEq6Q9CDjQdaDtrRF6MTjiU2fPCTXPqwJsmUCAoaOqipTU93zzGzSd981pQOuu85YMdBVuHWvvczA6yvLRtHW1jveEVLZyGB2vce5L+64lrtCR4MPDQsSgJBNwaTdINUWoqo0iyVdy/hVlri82xTB9YRsVshgrtNDEMBXMYXBxIg6KCHL2DFp1yLpdl1/dUm/ify7Jn5hDKgGkXvAiGTaNBO5P/igyWWfM8fMLG1rMwtqTJnSdexrr5lga0th783g2jQWHh2UsMA7jK6US5OssX4VlEY9bMsIe9oVmhMOLQmH8iIXVUiTv4F11WZP5XTJ7rwUIesLlVGvV5VypfUfD7L8Q6ew/IMnUX/tzfiZzEBfcgFQOIXDgsg9YMTywx/Cued2ifmKFYD6nFD8KP9aOw/Il8gCOhdheC+BN7M9dyylcftfZ+NTRgvL2Z+58h8sETw/3xZ0tCqb2sKksj373FXuq/ujLrIKjvQ8XhGijpJyTSQfsnyK3ATJV5cCUPv2alof+DczHvw/vPY43oY63KYW6r74bcZeeBYlB+67XddWsBSQ5z6sxF1ETgVOAEYDf1DVfw9xlwIKkDVr4I47oLHRlAhYvtzss8RHEf7ZfGznsdpDdLfli+yOfrC3/3UuDuVWO8XhDFVR19gvorQlbGJRZV1TBNUtxbsr976vbxpmqTy31/FG0IWJo7rGF9JZIeuZwWVNpkgsep2WBx7jne/+nN3e2QC+T+Od99N07yNM++PPqTnz5O2+xoJkmJQX6I8Bt2VE5C8iUi8iS3vtP1ZE3hKRlSLyPQBVvVdVzwXOBs4Y6L4FjCyyWTjvPDPDtLYWnnjCCDuAiOJo3lboS2iHn4+qCPV+DYc5zwEmas+4Fo6jbO6w+w0gK6IuE8syTCrPELZM8bD8teeSZxCU4pCZeVoU9nI3ELNFQ9qtpjv48QR1V99EZmNDl+/s+/iJFO9cdNkuYtvkU4n62YYBg+G53wwc232HiNjAH4DjgL2AT4vIXt0O+UHu+YCAbUIVzjgDHnkEPvhBeOklk+748Y9DZW4m6jinLnd0XxHt8Bt+csgyxV7PXs4biAXhIotIqYU4NlnP4r3GACpiLiURH8sy126JErIVx9LOW5stSmnEpyTsY4lSFt3yBuf5kMoIWVcgGiG1ej2a3lLEVZXE0rd30pUPYwqoKuSA2zKq+oyITO21+yBgpaquBhCRO4FTRGQZ8EvgYVVd1Fd7InIecB7A5MlBmlYAJJNGxB97DP7nf4y/fsEFplRvU5MpOVBTA+saJmHh4VMYqwjZePy6+CLCEageb4HmF6uGklafFWsEyS1l3V3mLVGKwtqjtAK5YyojHomMTcTxCOfmamVdKIn2rBvj+bCxJYLvdzOtXJ+qPcaSqd20ZWddD6eibOdd/HCmQMoPDFW4MgFY3+3xhty+rwPHAJ8Uka/09UJVvV5V56jqnJqamoHvacCw54ILTFXHc86BH/3IRKoHHQSHHw7pnIXc2GhmZW4/QzGRSamkib3t1xlt1VM11sKyBMsWxDKpnZXlMKqqaxi4O46lWw0eQ45ii+L6Nom0TSJtkcraW1xlU3soV3cmf+sQVGy8WClWUaznwbZNbK+ZRHeVnPgCidyHStz7+sSoql6lqgeq6ldU9U+D3quAgmPdOnjgAVNDZupUs2/FCiPmzz5ryvaCsQ3MpJ3tjdoH94NaRT3/W/Q1ZthvY+MRioD08Sm1bRhd3ZXp072Xri9bRO15PN+kTnYhWALNcbvTKlaFZHZL20ddl7YXX2Pct841jTg2VnERsT12Y9Zd1+7YBRcaql2L577XNgwYqmyZDcCkbo8nArXb+mIROQk4acaMGTu7XwEFxr33GktmxgyYPx8WLIA/5EZrolG4+mr48pdhMCJwwUexOCF8PweHFzAxWkvGivBSx2zA4pgzW6lb2MYbS4pQbPZkKREybGQsE6tb+ej+72CvWUey1YecrW2HTUnd/s/dlR3jKySyQiykdH+pAu1pG1t6Hi+iJDMOXptQXuRhydYybYy2TfrBRfgP34Xf0cHet95O0X57Ilu7m4xEhklk3h9DJe4vAzNFZBrwLnAm8JltfbGqPgA8MGfOnHMHqH8BBUJHh/HTzzwTvvc9I/B//CN87nPw05+awmGOY/z3gSZv+zyaOY59w0s5ynkSgGPLHgZbGP/hj7DkgWeY6+TMjpweqkLUhSklYawPxKhb4+IuMdUaV7xrM2eUsVq643nQsNk0YAmMqXJJpSxcX/A9aE3Y+FGP4oh2zkx1fUjn+hhzjPDnZTzi+Li+UNsSRsWiZOZk0qs3oN2iUAk51JxmCoVZIQersgJn/73Y5SgQcR+MVMg7gBeAWSKyQUS+pKou8DXgUWAZcJeqvjHQfQkYecyaZayXigo48USzbF5Dg6kfc8UVZjDVdfv7MO68qDMmSTwcftvxHZa2TKQlbpP1oKnd4d1fPocX93oIO5gBUD+tNG/0aNns88briuubOjDqW7y1QvA8k32YdwVa26GhyeTo2zaMqfSpLvOwfcVSiDmQztjUtYaobQ2R9aWbf24W2egs9ZsV2jIWCdfCR7CKYky7/FuExlRjlxSZToYcfNdj7a338vwhp+O2x3fae1ZYKIWyQPZgZMsnVHJgAAAgAElEQVR8eiv7HwIe2pE2A1smIM8JJ5jFq484AlatgtGjTalfyyK3DN62Rlnvd5UkQ0ojREiQooibUudxUfZyWhMOEUepX5XBErbww/Me+DtLXFK2vcUcmbYOYdHrwoQaI+SbW4XWDvOcYyljyjw2NVp0xLt8culxnt43L8FTJe0JnvZ8XmIRKj54AGNO+xg1J36Yhr8/yqqf/ZH46vV4OVO+dcFrtFnvUj533wLJO9qJKMMmj70/hl9y7zagqg+o6nnl5eVD3ZWAIeSmm4yYd3SY1ZUaGiAeN3nt7e1dE3a62NqHsq9jdwzF4hyuAuAZPkJeOLMejKvMEg37W5wrH8lnXCER77sfric0NMDmetCUUhnxmVKZpjrmkUxYtLbb9Bbx/qx6T3slUVrCmNOOZfYDf0JEsKMRyg4/gI53avEyvXwtVVIbNr73CUYqBZItM6zKDwQE9IXvw+OPw8w15vHKx0wVx5/+FPBdxAc3t/RdQ0PPwcKeDM6g31HyMLfphbR1Ls9nctNVoSTq0ZZwULp8d8VksbieyVrfWq6FlWtHxPjlYVtJKsQzQqiPME3EFAjzthCbvsXHioSpPOwDnYtzAMTffgcrEsJP9Sx7rKp47YlteTtGGFow5QcCcQ8Y1rzxBnzykybz5e6c53zxxaasgKoSI80X7es4Vv7JfXomt3oXDPjyd/0R12LSRPF6fTEWAceCmvIMybSFYxuZzbhCOiu5iURKQyLUq0UlJN1TGMX4+B0hWlMWioUtfrdKj12ELWO/dG8rbPlk/D7uBgqjjvtQj10le0zHT2e3OFREsEuL+3srRh6BLTOwiMhJInJ9a74wd8CIpLbW5K9/5CMQCpn67Js3myJg+ejzqtAXmCWvc5b7AH/zzibK0A/03ccZZAnjk6//Ypbra2h3yLomQnfsfFkAiDhKZbHL6PIsRRGf0rCHlbtFWaJELSVq9xYUyS3CkRsg9aUPN0AJ2T6jyzLYuVyesEDUgajTzR6yBKsoyrTvn09s6sQeLcQmj2f0yUdhxaI9m7YsohPH7IR3q9AIBlQHlCAVcuSTSpkiYNks3HijyWWfa5uFrffugCWvKa6rfD17Myl6L7fUly2z9dztnYmg3MfnqKSBEC5G2M0ziZSD7wlFkZ5T/UVMqiIo8bSNLZKLwpXy3DqpffVdVbBE8VTwVUh7xqoxdo9ii5nsZEs3I0bAcZSI+BRHPNKuhRVyKClOU1Hsoapb5Kzvf9uvWfHDq1n3pzvxOhJUHj6bsvjb2NGhWsRkiBkmnnp/FKS4B4xsXn/dpDVu2mSsiF//2gyYvvwyTJgIq1pN9KtITtjzHzbp9bM7g2PVKEKlNPOh0heYElqL096teyhhZ8uaL3k8pc8SvvnX9nUNlpDLeDEDpEkXsx6qY17jWEpb0mFCPosmt9iEZZv6M2XiAy540Pz7P2LXjKLiCz2nnFjhMLN+cQmzfnFJ185587bl7RiZFIi4F6QtE1CYpFLGVnmv2dl1dXDkkbDbbpDJQHExfOc7cN995nVr15qfRgTzX3/zaYw+YeIMdsmAPBYek2Qt54/7K6+mPsAZzq25MrtGVEM2nQOrfb5eIBb26N3/fNaL9vHCiOPnZpTmziEQdhRVU1+mPWXlKkiaVl3foi3pEA3rFtk0mkzS/LugGGu/FEi2TEGKe+C5FxavvAKnn27WNZ0xA8aMgW9/G+rrex737LOw++5m8HTffc1npLlZCYd8Zu6WxXGMzdDRkX9F939fC7DIUMzgF/vy2dd6lQqa2ajjebZ5LreVns4ov4GasizlRVlsy0Tsrtf3R862zFYW87C7zUbN64QPREJberllMY+yiEtp1KeixCca8fHVTFJKZsx70h0v19bW3iGvsXG7r36XQjFflfrbtgERqRCRe0RkuYgsE5FDRaRKRB4TkRW5n5U72tWCtGUCz71w2NwExx0Hl10Gf/4zlJWZAdErroBDDjGCPmGCKfb1iU+Y4l/f+IbJiIlFfT4wfiXnzf07X/zbfzFjbC1rW8ehyXzrOzbxSPCJ2SnEU0SUc+f9izlTl/Hi23uxYMl0EvEw0yKrqdo7xKZ4NXYijd+cIe7FmBTdyH9N/iP7lr5tsl8mRHjtlUoeWH0IJX4bkyPvclPpZ3s4RdGQIngkMg6KkMzYREJmYQyxoKjcwvFc1DM21NjKLE694vsQi3gUhT0iIci4sKmla9qQbXsUxZSKCg/f94iWCo5j4XmwcoXg96o41llmzLGhqBiSWw4+R/bbZ7vfz12LnRqZ/x54RFU/KSJhoAj4b+AJVf1lbhGj7wH/tSONF6S4BxQGng/Ll8F9z8Chh3btnzbNFPQaNQouvNAU/7rySvjqV02FxwcfBN9TxhbVsWDNbry98QJiToplG8fRJeg7Hp0rFgmviJiVJOnH+MUJ11ExFs7cfwm1q54nPCvM5K9NxoqaWumpezagjV0LVFjVIaQ4iiZ8vIYUu1fV8lXvb1SurTeJEtqzrrkIREJKIpOrTKlCMuNg28rM2Ra2baHqkI37eBkfOySEOwQ3qVQWGw9L1aRMZn0TfUccjynjPWzHpCWqKpoFX8yAqB2yyObsL9Wet0B1fTjiGOTZx9FkqrOTEo1S8+Mf7PD7usuwE7RdRMqAD2FWnUNVM0BGRE4B5uUOuwWYzw6Ke0HaMgGFQf0mKCvvKezd+fa3TeS+bh3cdRd85jNm4Y1774VkCtrTRagK7ekiEm6MnW23JPwiFOFX152MnPxVmh6qxUu5TDhnAnZO2AEklouWHSE8p5zQrGKcKTFCuxdh711O4waXtmbzibdsKBrlYIW27KsZAu6aDet50pmZIiKES2xiVSHCpT1jrnyg2BIPob6F5QvjqvxOYc+/XgT8rKLqM/qCs3FGVaEiuL3EXaIRwgfOYcKdtxL74GE448dR/NGjmfjgPUQPnL1T3tsRi7KzPPfpQANwk4i8KiJ/FpFiYIyq1gHkfo7e0a4G4h4wYLS3Q1XOMWxtNUvgPfggvPuu2VdcbIR/8WJoaTGleVO5QNK2fNZ9/xPc/blLyXi9J/V0Z9sFP2T3nIwj+Vz5lV8gu2gV2RUbsKsi2CU9K6Y4+5WDgD0thkQsxLHAUza9luT5P7Sw+t0QTW6EUKlNqMSmelaMiYeUEB0fIeua/HMzs9TYLrZlzu2r0tKo+L08Ws9TvGzXfBnPh7aERcY1/RIx4xJ9ldlVVbSogqm/uZSDVjyOGyvOlRnodt2WxbjPnEjssIOZ+M87mPbai4z/vxuJBpbMtqHbsMEoEVnYbTuvVysOcABwrarOBuIYC2anUZC2TFA4rDAQMZktF18Mt94Ks2ebPPUFC+Coo+Caa4yYO44ZbM1kTG2Y4mKwUK58/rNcfOjtSOdk/d5s3/dj1+sVESMIPhl1ePSOzcw7ppRNL3Z0Lo6RbnHZ9GIcP6OUlEdJrPax1iapkAzJjS5Llwp+LiVz38NDWC9hbgK5qH309DDxZp9ki4fnm1z2/OLTtmUmFTVu8AiFbYpLTcAnFrgI0bC5KVglDg21Qjxl98hB999jnozf3oG/eTNOdTUHPnojr57yVaTJLJfglJax39+uJDI2WMVsh9m2AdNGVZ3zHs9vADao6oLc43sw4r5JRMapap2IjAPqt9pCPxSkuAcDqoVBZZXx3Ovq4NVX4aGH4LrrjIA/9BDMnGmOO/xw8zObhYkTzULX115rc9nDX+TPLx7/HsK+fd5773YEH8fysfF56K0DOOFzzzJtv1La/1lLZkWcVIfS2OLQ2iY4KGIJM3ZXvBisXS+5lE6hohoca0u1FRuqJ4dYu9nH881sUt/X3M3DlBCwfahd6TH+A2EiMYtopY2fFqyQhROFsQeXUvtgCk3l8+PNbNfWdotIxOsRvedTJSUSwV29inB1NRWHzmZe3XN4cw9GVZn30vM9ascEbCd5W+b9NqO6UUTWi8gsVX0LOBp4M7edhVlL+izgvh09R0GKe0Bh4OdqkB9+OJx1FsRicPbZxmNvboa77zbR+rPPmoJftm2snLfeMpbDwQdlWfKa8XUs8bYI1Lce0W8L5rWub1McS5H2QmjGp/kv69Ckh+9BOmVh+z4OppRuJKxEo8ZaaWkzPRgzWtltOrjNLqGMggXqmxuBGdg0tXdFuqU1+mDbJu89mbGI5aL4tGvz+v0Z1IP9sj52CEgqXtpHEAQT8Tu20hEXSkuEWLTnm6I+kM1iT+gqIyC2jVOWm8UbCPv7Z+elsX8d+GsuU2Y1cA7GKr9LRL4ErAM+taONB+IeMGDU1sLkyXDi/5gUyGjU5Lz7PrS1mWNc1+TAg1lRqb4e7rgDImGPdWttfDVi5OuWlcMFJUyCNEXb3bdJsTpImsybilg7syevJLWoFU37hEaFcaojFIuw4rkU+U9zOJL7NSTMPKaI6nEWrOhAun/Yfcg0Z4lUh/FdpXWjZyL1zsBeOlc8LS92cT0Hzxda1maordPOgoMKuFl489E0lq/Ewr1EXIWN9Q6Tx2exbLoEJxIhcvgR2OPHb/d7ErCN7KRUSFVdDPRl3Ry9M9oPxD1gp/Pgg6ZkwE9ajQXT4ZkI3fMgGlVqKjPEQj5NbWFc1yaZND77WWf5vPRsG+Nrmjmm7DYWvDmZPz7zcfaufptn1h/Y7Qw+YOFj75CwlzrtrE8a8bPwaWov53OHPU7mnwlKd4thl4WwHaGtNoOX8MjnHSQTICEoOqKSorBFZnFbnwUC/bTipn0yKaX5XRfLAt8C9SBvDkUcn5CllMY8EmmLlgYrN7Da85tIJqmEe93X8qmNWdfi3foQ4ydY2OKBbRM78WTKfvTT7X5PAraD4TEBtV+CbJmAncpVV8HXv24GUUtKTE77+PFGkEZV+5xzxBOU+LXccObPWHf5mdiWR1mpkkgo3/2OsnHlBq69ZQKX/O0cyqPtfLbyLqJdU1Jz7Oi/rWKTIeGZG4Kdq5z+pzk/pqI4TqjSIRS2sBIufkeW+tdThO0uLz2bFbJVUSRsYTmCpvoe1VSgYXWWNS+nsRyYckgMO2yRVwXF1HW3LHBspazI22JFpO7kSxZ0bpjaOgBpu4ToFdcx+uVXGfPqUsp/9VskFtvB9yegX/KpT/1tw4Agcg/YaaxaBT/5CSxaZOyYdd+Fxs3Qkja2zIFTVnDLU4ey+mdnUlnUwVVPnkY0lOGjczZwz1MzEBGeeWNvKkvaWVE7nm/f+7XOtqeF38HJuJ2CvGMIHuGcxipRO8OMknUcOrkFb1M50ZTXaZ/4ruKmFceGWNjPTeUHrQgjjhFWuzqEm+hjLECgbEqYsqlCUZWFm1YyCePxqxpjJpW1iIZ8EmmLpo4QYXvrA8SmaqTRFU8BtUxaZVGMmk8eS9Xx8/pMiwwYIIaJePdHQYp7kAo5/GhvNyV6bRvmzjXL393vmTowiSwcdZSPrG0k603myic+xS0vfowNzSYd7x/zpwMg4oHatMZjjC+rJ5Ow6XCLSGgxHX4Jexe9RYdXzJGTFrNk5QSaqaT7v7AtHmNLG2hNlhDPmglKxrzxEDzKnDjzxizgS9Pv5YDKZdS8sBQU0h2V2AtakEjuG0FWsXztHAQtiviEHZ+sa6FxF/XDiCU402K4dWl6zxJyqhxClaZfnqusfSXTQw/ykbfvQEfKwbZMLZiuZ7uE2hbFsrqqRWZ8sFFCtlBx2nHsfv3lgbAPMsOkLli/FKS4B6mQw4uNG+Hoo6GxES65BD7/eVM/JvXxrvVBH3lEiMj+JLNRLn/48z1e7+eEy/Od3GOHDa1jGeU0UmQlEIRxFc0sb5rJgSVL+PdF/4WzVyXZzVlsP400p9D59ZD2zQl90AOrqLtpfQ/rpHSfEkqrbcgoYuc+pApO1EK6lUjUEAgW5WNsWjd5qA+ODY7t4zQkQY2tY0VtoodVkF2VwGvImtRICzTqgAVttS61b2Rob+hp3whmTdW65ghgct9NSQEf1xf83GUISsjR3HuSuykoFIWU9qyQvOsRQuPHMOvyb+60v2VAP+ykVMjBYJvMSxF5Ylv2BYw83n4b5s+HZcu2fsw555iiX3PnmlK948bBYYfBnnuavPVx44xf3ZHZtmXZJo3aBECjO4pGr4a4V8SSxpnYIWVz2XjsmRMg7qJvNSGuiz5ZD3HPKF82510s3Nw5mUgsGH1wOWU1IeoWxqlfliRZn8FP+7nne+W/i0DEYsxeUcbsFcHqDIEUK+2Rfb0dP+XhZRRsi3RZlKWLIBGHRLuipTZUhVj3QoKOht4lfBUEWhNO503NnNOkWIYdJRo2ZXzFZFECxi1KuCAIbVmzTpOXSLL2qlvxs1sugxcwgGzbDNUh5z0jdxGJYiqVjcqVnsz/N5YBQa7VCObpp+H73zf102fMMJH4mDFw+eXw0Y92Hbd8uZmgdO+9purjnXfCaad1PT9xEsiq7Tv3+sYx7DN5DWs3jqYjY6JkRUikI6yrH0XNuvXE/7oBKXUIxaoha0Ta9xTf9VEfxBaKK2xa2z2qPzqRcDoOrk824ZPxzDqiUS/nZ/tK07seTe96WDaMmh6idIyFFbIpn2RROj7M6/9OkE4oo13I1qVY+584bRrBS0Omo2dk3vBamknzQlTMjNCyIk0mK3h+btk8S8l4go8QFh9PTXwlIkSKlHSipy2jChkPEp22Tc8bkZ/J4rbHCVdVbN+bHLDjjJDI/XzgFWCP3M/8dh8QVPUfoTz6qMk9/8b5Dbxzz2+Z/4OvsPrOX/KDb9Zx1lnwj390HTt/Ppxwgikr8PnPw3PPmYU18ghQWdn9EYASCWXZIqLtxhvrpjE1sgHJDaBGSCMoyUyYV+8uJ1IkRGzfCLuAl/VxUz6+ayby+FklVGTh1MSIksFNesRbfcbsX0RsfLTTw1ZfWfFihnVLs7Q3+rRu8lnzUpraN0w0LJZg2TD1gAio0FGfpaM+i+cJyc3eFsIOkE2afWMPLsIpsQjZSiRkNkWIZ2yynlAU9QnbPgpM3k2YPNNCVTozYvKbqxC1FKcPaz1UXkqoomzLJwIGDn8btmHAe4q7qv5eVacB31bV6ao6Lbftr6rXDFIfAwYRVTj/fLj9+vV8qvJ8nI1PQ8d67E3PcXLJhdx7y0ouvNDkreePt3N52GVlcP/95vVnnWVmoba3G2unJ0I6GwIE2/KJhLN0j0hDVpbx0Tr2jCzHAiKSZky4gaikAbhhxenY0Vyp3MY0vusbi6T3WWyh8qASvEwWESgut4iV2oyeHiJSEzK54kkl0ernctANvgcNq1zSiS7bpnycw8QPOKDgppWiaM91ULtTMS2Mekpqo8umeqEpYdOWstmccGhJOuRLliUyFhWlLvseaTNmIrS29MykE6CmLMOkyiyxkIffK2K0iqLM+vV3ECvIaB408tXcRkoqpKpeLSKHAVO7v0ZVbx2gfgUMEc3NJtPlqIrfQVO62zMKXpqD7CvYc88/cu21sP/+xqp55BEz09RxjO++dCncdBO8c6+paJjJ0Jl5Egn7VIabKNE4K+OTEXzSmZ7/hrYoRZLk/saP4YhLWsPsFllNJhPCwmdR695dpW7XJMgk/D6jlGQc1j3cQWsThKMwdQ+bMZNsrOmVlJw1Fb65meS6eJ+Blgh01HtEplqdj0Oui4oR/0jMp6TIpyNhdVv31GS2ZN5qp7UuwepVgviQ9QXX7zvF0bYgUuFghyzW/SdFWdgnGvYIdxgbJ+yAr0pp1Kco6tOUjJAJxSiaMYWZP/46Y045Znv/xAHvCy0YW2abxF1EbgN2AxZDZ6KxAoG4jzASSTj4SKB5ZZ/PP/WfcpYvVxYuFGbPhtWrTbner38drr3WHDNqlFn3lH/Bxto04bUuju0RT4Zxs0qrW8wHKt9gSngDL7TOxpdYj2An5YVZkZwGCJZ6gPBWcialdgdtXikx29QF9n2ldUMGtz1D6bgI2YRPvNHFzyq+LazcEMbLedXhsRHsY0bh7xXDri5CyqOk4x6+n6vGKBCOKFVVSjhiblbhsSHkiNFQGYakSzS7kUxdxkTvGRhTnaU4ZtHWYb66OCnF9YRVqx2iYZ+OlOTWKe2jNC9QFPJQwA5biC3M2BM2r1GKI4p0m7clQMhRfM9m8qePY/rNv9vxP3DA+6cwtH2bUyHnAHtpXyv0DgFBnvvAYdumiBfhYkj3XKP24UUHcs7V32KfA+Gkk8xyeJ5nBlK/+lUz+HrllWYd1DVrwF+Rpr7B4aIvLuDKGw8BwFObpMZ4qu0wXpj3GQ5+7K/4W4ifGVQMSQZXTbT+s0OvIfV8FIAzJz6EqlL3ehJPoLgyRGJzlsTmrglFGzc7nQtxl+4WYc6vpmCFBcsSyGbQhnr8tNt5fCSqjJ/QlaESnRaj9LOTwRGTTVPsUP7pyWTbfVKLW4mUOThRIRTzKC122bDR6VyI2vUt4jlh9xUclGyva1Qg7tpUVZGbvQqVY2wimSyJpl7vhkIibRNP23hvrtnRP23AzmJ4yGC/bKtZtxQYO5Ad2R5U9QFVPa+8vHyouzLiqK42NkvTqNPBjnTu9zyLC677Gjf94mUWLxY+8Qmz37aNx/7AA/DMMzBvntl38MEKfoYD9tnIZRf/h4qyFCGnywBJZ0Mc8NjdZAn30QvBERcfm4id5bXPnc7K5G6kvTCWpXz2guVkJ1dRdUAFY44dT9Hh40i09ZxIlMiYSo4AM88ZjZ0X9vwZBKJjQ9i2KZVbPcpYKnkfPXb8OCTcM/9dHIvqz0+ifFKEWLlNOGYTqwxTPDpMWXXPAjCK5L6N5OwjugZI/dzzKc+i5gMmPVQ9RV3Th1B0y0g/kTGdi0yduMVzAYNI/g9Y6AOq3RgFvCkij4rI/fltIDsWMDSEQ/C5z8FZPzmF5JjjwAqDU8Sjrx3EmBqPm588mhNOgIULTZbMPvvAkUfChg1mMY5rrjGWRn1dK7tNaSYSdimOpnji7geprk5RXZnsvxOAqw7VRS0cP/M/HHXfjfxi4TlYouw/bS3OPYvxXmuAug78JQ2wpJFRF+9L6AMV2PtUUvzRMVTuEe1sq2xGdItcdjADrrYDo0d5RCI9n3PG912fRYodswRft/YsWxg3ceuV5UWEfGWZ7jFf+fhQZ9QOkG3KmlLBoa7F+FwPGtpDqApWLMrES778nu9bwCAwkgZUgR8NZCcChhdXXAHnnCPs8alz+dI5X2DWlGZuW1jNWxtCjJlu6sX86ldw0UWwz55Z3pn/Fr+5ehwLllfxhS8I5eU+hx5kcWs6QlHMhbY4++7dwooX7+H/7pnK3f+cwlurq2hsjuK6NqpCNJRlz5o1XHLEX6kKt/K9R7/KssZp3L/iQ5SXJPmvzz/EoYtXII1xkqlol0r6SrolS8OvlwKgGaXjDYuy8VEiJ1ay/sFmMi0uoZItSwaDKavbEReKy8wkojzpl5uwx0Rxphf3vDG4arZemBrtRox7o51FfrvfEGDyHjbqK37GJ/lO0kTvqrRJCaN2n0mmtp5NyRIk4uCUR5l+1Q8pPThY43TIKRBbZluzZZ4e6I4EDB+SSTPrdLfd4MWXIjz97FgyGbNyUnOzEcE//hE+UL6c+m9exNlP/47F7SaZ3fd8YpE0/7ivlK8zhlFVGWZOPIywV09Jicv5p7/I+Z96DkIlUDmr85xavxHu/DM0ZyDp85EznjepJLEQzK1BHIXFWfyE2yP8VVU2b/TQbqmQmvLJbEgy6qAqNo8L8c7dm5l1wVicaJd6e2kfv9lFFVxXiHcopeXSKfDJh+vAsZCoRemXp2OPiqCuj7ekuc/3rPtiHLledFox+UU23NzXdQFKbJ+2txLIJnrdLIQZTz6C/dnP4VRXcuB1N+CLTXTGNMTu+wYVMIgMoxmo/bGt2TLtdF1SGAgBcVUNZk+MIDzPZL8cMNEIeDpt9lmWWQIvL162DUcdpUzUEM3+7dTFqzvFTVXoiIcoKfawEsrmpjC/vHAOt13zBJpNgLqAQOUspGteP1peDikfchOAjCfhQ3saFtXDQTVmXy97xbUsfD8vo11oRml7bjOHfnssiWcaWfv3RqZ+ohowdkzz081EN+WS9RHiWWHU3sVkl+XSVHwg46MZn45b3qH04hnI2jisbOsy0PPnUiWbBsfPS7niWEpJzKUjFWLiBJeSYkiloaFByKaFtA+r1lnMwKekKF+oUgmf9EmscePxazfg128kff4nwbKxvnA+4bO/EhQJGw6MsMi9tPtjETkVOGhAehQwJKTT8ObrJlgOh01d9hNPNH56Q4PPxjoI2S5hx+O12x/lsr8czqNPVtOYNIPa06d2cMjs9UyLbuCtjlk89Vw1kaxLKuPw93tH89MfjGOq9RJapNDmIpUufsMa9N/PwVvr8DJZ7KjXt2/dmkHT5rn/Z++9wyWrqrz/z97nnMq3bu57O93OEbqBJkmWHARB0CEYUBEM4/wcGfXV8XXGOOooY35UzBiGoD9BQFGQpISGJjRNd9M5d9+cKp+03j923VyXJK3dUN/nqefeqjp1zj6nTq299lrf9V0qpscY19hFbfCVyvoGSgO+EISw9eZetv26h2ltGr8/ICyFzB/1G7VqHCRfWU447HMJfrMLK6rRMQtnagSv3bTDExHcgtC1O6DNMgGYxqSHVU7OTp/pDSdy4zGYMV3YtBUksPBCWL/VxrZM67zmOQ0c8vkv4f7iB1id7YZQXzS0z9JPvws1aaJvfutL/3KreGVxgCRMXwgvq7RNRG4FTnuFx1LFPxA//7kxRp5n+OpvfauhOM5qE7zBDCfPeZoz560kV4py8ruOY07wV3oKIwu35Yf08f3P3U7CydCWeo5bv/CNclNo0//0lp9byOpVyB/+SvZH99P7tVvIfez7DPzuadof62UgOyGuMQIFFBU4EVSN6ZSEAtUSI7o4jdM8kXGjIpra06cgj3cT9Hm0NIc01gpup0dYGmvElQ2Np9Qipcl/teKNvGfXOkTnx8nmhF0bAvZuCTZCQLsAACAASURBVIbb45kQDIAQTzKGoQNmFdTUUN5P+S0/UBRdhbzuVNCa0g0/YHiHQygWcH/63UnHV8XfCa+2Zh1KqYtHPdUY3vuBcQZVvCL4wQ/g3CbYtWtE+OsHP4C3n7eTwbV9fOH073LFzZ8hZrtcvOR+ntg6C62FIFTU1rq8/Y3rKH7mZv684SdcdfHDHL9sE09HPUSg5Dr078vhRrrZe8MeQmykuBUJjWHLeA5qXQ/B0VGal0YneO+hY6OOOxEVWQcRIfbtK/F/di9kBkBg+rUL2Pnp9YgXIoGAViSWpUm7RUo9HroQMHPqULGSomsf5DIj+xdbE2zPUup2sUQqhj50XCOjdQEGAyQAz4VoEoJRxbwixognUpWvdTQiKCVjeq/asRitbz7bZGYzAxU/J709z/8lVvH3QYWE+oGIF8uWuWDU/z6wHbjwFR9NFf8wbN4MuglSNSNaMZs3gwx0cOTUTRw57Tl2DbYwt34vT+5bzHmHPMF2FrJ+Yz2WX2LLn3dQt+gs1t4zk4tPfhyAZLzIYC4GGmY1d9L5h0GCYgihsYQKsLUQUz6FooW3t4TMtcExFZthxodeD3xBPn4j9OegPomK2NjvPh156H6wFdEZceZ993CyT/Tj97nE5yeJ9hUI/tKBN1gO54xaozZNVXQNlFfXAvkB2PpAkZZmob6hnARVJuQCEKtxkA4XYhYokIKR+y1mjC68VyznJBjhw7ihwrIqV6aWSpCKmZVAEEKWGHVnHE/TeaegtEbNmAXrd0/4rJ674G/8lqv4mzGkLXMQ4MXG3N+1vwdSxd8XIoar/uyzkEiYBtWC8USHkE6DiiXpyDfTkW0gHc1xxrzH+MXqc0jMaiBNN1BPfy7B7585mi/feSm/+uS3cGyTNM3k4uVjKS455mH6bsxO+GEoBVEnJD3FpjYl5J/JYjdFsFIaa95U1FG10JlBVu+GnqyR9ggC6N6Hqk1Qas/hNMXQUZv06xqM5170Cf+8G69QOYaugPnLLGq2aLySkIpBMiqk04zoxJRrokrZgEitQ+gJuhwqCQPBKwmZ/pCa+VF6t3jkvXLTEYH2jE00Bk5S8PLhmDVuGBjNm6HFgW1BfQyWfOdTwwJgsQ9/Ev58vvHihxCNEfvXf395X3YVrywOkpj7iw3LzAC+BZyAuVX/CnxIRCa6F38HVOUH/jY88YRpiTcwACecYLRhOjthrw0lFzZsgEWLjOxvnzOfO55rY0ZqH5ccch93bjyB//3nb3LLhlO5+y/HAhBi8eBzh/GVS7/PabMeJQia+fotZ3N0YTsAbzr5cWqb4vQzeSyvobH8TwhBQRH75JmQjqFiDlL0UBcuh3O+CwM5WP2QsZJhSCQWEvblCLSDTjjItgyyshNKlQ07GI55TdzERh0HFh1p4+UUpT7fbFA27CLgxDS9W4tE6iOkmmyUgsGugL59PnWNitYzUsw4GVbfmMHbZyy2j2JarERpUOPUWIQlIQyETBYG+0ZNIEMIA7p/8Eumf/ZjADgnnorMW0S4bzeqvhE9bwHR934Ye/mKl/5lV/HK4tXmuQM/AX4FvKX8/G3l187cH4N6IVTb7L00PP00fOQjpptSGBpj/o1vwHveM1K489RTMHgkRCNwxRVG0/3DH+rnxJOTLFnucd0jb+O8k9dy6PJeznt3J+HtK7npT0dgWT4lz5R3Xnvj+/nYze8lFEUoivv4PrYV8MP/ewP28Rdjtz2Bu2nvGKlcpU2lpijAVjjzEjjTY8gdq1DHL4LF01Axh2DVNiwbqLER1x0uLFJRC20L0lMg3NqL9HsQhqiIxk5H8EqliTFSYUxlqFYQSWiCgsYf1ZZPKQUKIlHwekt0dZXwAk00Cg115dDNPhdnWoylF6Yofc98bmraJR0PGeiDfZtshngLtg6JRWSCVLC4HoU1Y1tdqZo0Vs1Sau66/+V85VXsTxwknvuLZcs0i8hPRMQvP34KNO/HcVXxCuGqq2DFCti7Fy67zDTVsCwj9HXLLSPbHXEEHH6Y4WLv3esze1bABz4QkK4p8cjKeoJQcecDh+D5Fsvf9DHe+rn3kYyWaJ1SJJ10sW1h7oxumhsyaCsgHc0Tj7isWLiTdIsNhMTOe52JWZdtbShQP90hHsHE1Ysh7nNZipvzUK+R+5/Ff2wrhZufRq3eDJbRyJ3QFs9SqIYIOqLRTRH0YWn0lcuxP3osMqehrPwo5QdYcYUeFw9XWuEkx/4chmLu2lZGmdEyjUAKBSjkzTb5zXn69/qEIdTUmlDW3KUOdXNjRGojjK5KDSZz+CxN4sjlL+2LreIfh1cTWwboVkq9Dfjf8vPLgWrq/gDHV74CP/2paYHX02Mojjt3wtKlMDhojP0VVxjvPRYLuatoGjJblscpJ2XYs1sxpa6P097yHE2NBdatSrJ1Sx21TjdXX7yLd3+gi0Pm72PNfZ1c/+tjWPnsPAoRh+MP3cQV837H0feuQ5VA7lmNZCzs1noKKoH2iogIsRrb9Ccd8oQUxC6cTeSYKRgqiaL/wU5q27tQ6Rd3qyptdFmCdXvxdnjsuKsHEairAxBEKaY2VK70rCR6KmWLPFSk5diC62tKJSESgx1rhIFVWSSE1wHJBFhRjYgQjvuRiyhCETQjMXcBtG3TfPXbXtT5VfEPhlSWnzgQ8WKN+7uBbwNfw9yPDwPVJOsBji99yXRE+uIXIZUygmD9/dDbCx0doJSQTnnUpAIsO8TfqaipCbBUwOOrUvzya7/mjJN2QiELnkuoE6inu+GIJaipzWYJsPFJlrWV+Na1ppBIghBWbgE/RN1bDl67Pjz0ODXzZiFhiBdoAlE0pEGNWuJGTp1G5OhmlDPiQdcf34DepWFDj9lXECKhjPHeJRQYHGkSrbSCgQL+6l5KJeNtD/QMyflWXlOHgVAaCEYMvJj9igihP2LgtR6hQ4YB9Of0cN4zAPJ586OSEHq6KhwnHMvcQWtm//RbOC3VhfBBgSFVyIMALzYs8zngShFpFpEpGGP/6f02qir+ZuzZY4x4LgfLl8Of/gQXXwzbt5vXV/3pGZbO2kX/oMO67/8zW3/0HmZNHyCTsZja0MPN//NTrvjQxfRsGYD2nZCegZ55BOoNp6FmTEXZNuR6IfTHHrhnIiNmCI4jtH1qBc3vXETLaWnqT0zDKCc6evJUVGSsV23FLJg9qvlzIQAvRHxj5CUQ00G6pzi8iaEyKoKTZxBpMfmAYZstsGeDRxjIcHJXQqHY71Ho9Qm90DzK+zcNqGT4s8MEFoE9vVZZ+mDkuL4PxYLQvlvIZ4deNbz2llZBa4VoTWhHCCMxWj/xIerOr3ZTOqjwKgvLLBeRYcUkEelVSlXl6Q5g9PQYT/NPfzIGfaj6NAjgjNM8Dg3+m30930EBj6ydwxkr1tA2tZsde9Lsaq/l5KO2cu5Jz/GTu07m396/EVU/0whXWRoJXCTbBx2bwC1CsgGSTRB60L5+QqWpZHwoBEjYSTKZJvD6qT+zBtwQb01mOBit4pMIY9ka8ULTeTQEnuwlrHXwsiFoIZK2xxY+ibD5twPk+gaYfuUMdn53B54rRJTx3nP9wuZVLvOLgmUr/FSEMBNSt9jGG/BxBwJCNzQTwDjSzVBDjpJY9OecisPdsCYk9EyzjiE5nEXLNdE5s7Cu/BcyO3sR36fuvNOJzZ/9Er/ZKv7hOECM9wvhxRp3rZSqHzLwSqmGl/DZKl4kOjrg+uvh5ptN+GTuXLj6arj0UnAq25FJMcQSXboUhnqa3Hef4bSvfNTn1gcPp+RFqUnkueepZZzy+h527GzEcQI6e1IMZGJcctYzfPfG4/nI+59GhSUIXUTHYevj0L/XGPEFx0PNFBO4D0NU6xJk8DfQvs8ctBDAzgJBPsB9bIDo6xtoXBIxoRVbkTizkcL9vUghJNiZxZ5bQYuuv2R+UEOJ2FJI7qE+sttLpP9pAVE/C1bZuw6E7XcOMLDNQ2kInuxi5uWt7PlNJ17Bw1FGrTEMjKG3HEX0gjnEZ6UJf7+ZaHueUmeJ7LbCmAxoEGIkAkQRnxvDK1nQ708cK9DcBB37zP6TScWMeTaJC99I/KOfRsXiJF7aV1nFgYSDKCzzYg30dcDDSqlfY07vn4Av7LdRvQaxZg2cfTa84byQH36nndYpGZ5c08L/fLOOn/wE7rgD4pX7R1REImEmhzVrBCl1oLx2gnwtjj2DT1xxJ1d//X3kilEWzOzg3meP5FcXnMwdpYeZ0pDF6hOCUBNxAoJAmwAyAAK928qGPYSmOVAzBWWVbyOrHOU75wLkdzcZDqEEeIM+XmcJa1Yc3WR0YIY8bbsxQur8Zgr39+I9uhdrRhIshbLK5f6hwDMdI5IAAmFUkVyUILUkherrHjlpBQRCW7Mw/WTTZQntonZ303SCReBqNCGBC4O7ijjdCiIa5fuQddFnzkF+tY741BhOg0PPwwPDk4ZtKVIOxJos0hfW07g+T/t6r9zKzyiZKSAeE5qmgFcIKRVAWxbZBSfR/Kkvv9RboooDEQJykCRUX1TMXURuAC4BOoAu4GIR+fn+HNhrCZ4Hb3wjfPXLeX7wxRs4dvGdzKq/nzedfDP3//ZOWlpC03D6JeL6630yGTj8CJu1a3Zy7BHrKLnwxL7DEeWglDBYrGHuvBK3//KPLF+4j57+JA21ORpq8/z+wcUce9hOiDeM7LRnx4ixb54zYthHIxaDc8+AmiRBf5H89gJeLsSaFpuo+uiF0O0RX5wimlTIyl3Ql0fyLvTlYGO76agxBAU6G6CboqhgnAslgC+oAGzH9D4dOp7yBVuD1hrLUSRbI2YSUQKr9iF3bkIe3QP1JkavtMZJ2yilyo8ywyUQgqcGsTpLHHOsorUpJB4NqUsLiYQpilIKUmnzGXEDBv94f0UmThUHKV5lMXdEZB2wbj+O5TWL226DmTPhivPuBL/A6DpOK9jD/3x+HUuOPJQvfKEcYpEQwgxmfaggzIKKgzIxaxGBgV2cungtJx27jHWbmlh2/AUkEj6Fgs2Nv53HKcfvpamhyO/vmcUN376PaDSks7+Wkmvzb1fex8ZtTfzqjhU8dfv1EGtCQr+cUZy88nMYSqG0Rbi336gpChCNoFpaIeZBsUwSF4EeI8qiLFMwRFLB7nEdousdE94ZjWkJw5Bxw+HLIIEgnS5hIEYuwJnIZzfjg+iMKGpjOSg+FH7ZmzF6AC8A6ffRWhGLKxYvt0zsH7DXT/qJF9xnFQcRXmVhmSr2I/78Z3jzxSXwexlvCDq6HHbs2cPChYfy8MNw7uk7ofS02S7sBzT4T5rnug3pziF//jyUBkF8fvmVt3HKO97MOafvZPGiDPG4z6f/aymPrGrBsYX5c/o5/63nYtkBn9j8K9LJInErz2nvfB/X/fs9zFxSB/kukyxVClpnwT4fcgPQvQ2J10703iWE0CUcNAyW6NvOIvGeC4AQIjbs2IjcdxsUXQhkxJuPTbKQVECqfAwBTxQxSyFLaqHfRQY83C4Xa0eOQodHoc8f5qVHayxSU6NjlB6VVqhohWMFMrJKEMHLjIupK3DiekKzVG2rYbpk+aPkBsvPbYv02adVm2y8WiAHjmf+Qqga9wMAQWBogqOxcUstH//Ccdz/8DTmz8myZj28770BX/p0B5e/xQMrAQwZGuPVSn498vtvg2+MqjrqLGYsbmLlvX/ma99ZwLe+P5/+AQfbFqa1Fti9N8Ga9Y2swfC3Pw4M5mLcvfIQbvrSDznxiG2Qb2N4whkKLbTOhp0boGs71E1HappNQtX1TRlnvrO8Pej6FImrL0DFRzpQS9tCOOkNyB/+fzPOoTeez/6p8sNSWIfX4xdCrKgiSDhke4XBP7aTiIQErkm8Dg21lAlQ2iXZEkFCUI6J5U9mbEUg9IXup7LD0aehTaO1Nk7CGvNZ031KRuSAxejHlEoKnUpg1dUy42ufe54Tq+KgQ9W4V/FiceyxcOutUd5/aRKCQTZsruP1F1/Ite9dzc++eT9hdBmzDm3iui9u5uOfWkJHZ4R//XDPBGMom1dj2tiVsfQ4lNdNcxP813+u5Qv/sZZiPiBKLyosIqUC2Y4sjioSs/LINZtRYcDJ137WdHrONUGD6bMnro+s3ATP7ISogzruEJhdZwxfzz5k117o3ArKQ9U1wKw5KEehWxvHGHYA5Tgwdyn5TTdhT7XQaQfJ+NiuP0F3xXxAQVMKaqIQsdB1KQrrexjc5bHvsQKZzUWWzg4JPJkYAREo9PmUXEieOZf4xUvwP/eniktrEcHPh7Q/bOiZkbgiEjVyB05CYycmSh8A7N3qYUc0jgu2EsJQ0fLxDxJbvJD0G85ARyY2E6niIMYraNuVUhawCtgjIucrpeYANwINwJPA20XEfb59TIaqcT8AcPnl8PGPKx585jxOPvQ3fPg/TuT/fPAp/vWa9WCl+NiXV3DuufDmi/ZwzBFbOOyEM7j0sseYOn5H+QwEZeOutOFPjspFEpaI+fsYujuVbVMzrRZ6syYRGfrg+ZAvmO1dHyREPEG++ydToOSXVwm7e+D45ehL5iGFdtSeNUhQbpNX2IN0tqNT1uQx7FCInzYdihkjGVDvGBZCZ8FIDQxZea2gNg5tjVAucNIRSNYrYikHt9ej7ZR66hMhPbd2THqN+zsCorObUU1G2zjsdUfXTxnvO4Cuh/uJxywsp1x5GrWwIwptgYQKUcbrNwVNwu5tQke3g1IwTYuRUIgKUz7wLvQQB7WKVw/KSftXEB8C1gNDHOAvA18TkRuVUt8DrgJeVguul9Vmr4pXFokE/OpXcMmlDXzif97Jyqemcc3VsGbXWVz5b5dyx50W3/wmYE1h5owil75pFz/+WSsAEoZIWYRdNU8FJ2IMqq3LpZqjTFihhzFuh6mnh9pmU3rp+WMLkDKDiFLwzA7oGzHs2JaRj3xoNdI3CGtWQjC2/6kKAlTCAbdo9NfHQ3yUlxtRd7Q1ytGEtgXT6mFKGppTMLcZ2hrHhlEyptmH5SjaTknStDiK9kKchsrFAGEIoiziy5qQvQMU8kK2O6Q4EOKXhHyPT8c6l1139RK6UMqNjLdjZ8BgBnAUogFboyIafcJp9FkzKQ74NNYFzJ7uDjNBdVMzKl3tHf+qhPCKsWXKUupvAH5Yfq4w7Ut/Xd7kZ8BFL3eoB4znrpSaC3wSqBWRN/+jx/P3xplnwr33wrXXOvQPQF3biTQ3myKmr38d6uoE2bsOohmOO3I399zTguRzppdbKY+svhXxsnDYPFTLYkhNAUJwasHto1xHX/ngdtQIuY+CRBOohcehIhHCDXtNib/WqEvORJ24wkwMxRLS3oHKVmgLF3cgagFFIEBEocqiKmHRRR67GzWOHqgshapzYOcArJgOWk2MjYdiOjINfUZhxrWsjlRzjL6f7zae1dCuNRSKmpqzZ+FMieNf/wgbngiQEJa6glcU1t+VJxUPSSeMmkIYQKgE0g7S4VM/w2HDqoBMn6lgSTVZLIo9Sut0TX0kQWZLfijtAVqT/vTnqgnUVzNeHFumSSm1atTz60Xk+nHbfB34GFBTft4I9IsMx1Z3A9Nf7jD3q3FXSv0YOB/oFJFDR71+DvANjLLID0XkSyKyFbiqXCj1qsGmTfDNb8JDD8H3N0JNCgpPGYnd8Vi2DD7zGejuhkcfNfK8Q5A9t4HTj8Kip8sirgrGsIvA078BAlRDI7QeArG6cuggAMuBaAP4WROqkYrBZsMSGTK2SqGOOttUTWkNqahpSP1PZ6NedxgqUvaQHRsSs5D26ajuPSP7i9mQLGsLSwjr74LWQ5BUM3gFSg+uIdK7zqwuxg+lGBK25wkf3Y1MSWNNSaBroxCEKNcHLxgb84xaJlyjFc60OA3vbiP3lx78PUWsmMZqjhE9cj7ppbXI9/5KaWM/CDhRUL5JWzTVBSTiZqe+mMhWIRlj2kX1BCtzPH13CS8/ctBMV8DTf8hx7IVRolPiWK0tZHb6qFwJa/p09OlVrZhXNV6cZ94tIkdN9qZSasguPqGUev3QyxU2fdkxoP0dlvkpcM7oF8oJhO8A5wJLgcuVUkv38zj+7ggCo5l+2GHwwx9Cfb0x1l1dcOKJcNFFRkFwPI4+2nRFeu5ZD2/7dsKBAcNb9zaD0ojADT+fxRvfMFBWqcoYVzOZBDsGdgJ8Fwl86N9hDLy2IFILyXFR+sA3nPNcP8RTw507pGm6OWYmg/gealkjxKOo4w5HRccmB5VloRauGGGLACQi5mSHG4rmYOdjsO5O2PwAkYVJStsKiD92ogndEDZkjCxAvU3vl9fQ828ryf0lh9S0DBt2Px9QaPcMhz5qDPsQ7OYotRdPo/F9s6k9tYFUSpFesxlueoJg9wDtW3xEwCsJljISxzW1YEUVVkRjRaDoKfo3emhbIwlnOI0xZqwBdO0MUL6LI4M0/fo3OIsWo1M1Ezeu4tUDeREhmRdn/E8A3qiU2o5JoJ6G8eTrlFJDTvcMYO/LHep+9dxF5EGl1OxxLx8DbC576iilbsQ0235RBVJKqWuAawDa2tpesbG+0vjkJ+Guu2DxYrj7bmhsBF5vNEpOSZnepe96F9x009jPOQ78y2lP8vYTovyi9d3USg+Jc8+m6f8uIhgs8fE3pgh29bP4U++i2LsPpymCjqWhrh6Vz8L2R6FhBsSSIApKdUgkDRJArAUZ2GEOtG8bZPtRM5bB1MNgqkDtXyCXhU3t8NefI7pMtVw6HS5aPkEQbBiJGsh6SKrs0WtV7gdawRGREB1TWIeswHvuSZyZcSQQ0xB73SB6bxGpSSJP9NG0IGHSBiufg0PrkHic/NYMq/6jG6VBa8W8t9bTemJq4nEsZaQBCiFhYBYRHVt9enaZ+InCnI5yFA0LEzC0IAgFtSegY0dAEEBpUAjdiecd+lDMDnHZHeidPJlbxasMr0ARk4h8AvgEQNlz/4iIvFUpdQvwZozBvxK47eUe4x8Rc58O7Br1fDdwrFKqEaNXc4RS6hMi8sVKHy7Hra4HOOqoow44wmkYmhZ1X/uaeX7uudDXVzbuGPmVG2+EWbOMkNf69bBkycjnC/c9wOV/vYZt1oc5fdftXBa/kaPW7aX4s/lc/9VZFLLwo/Q7UX65MjMRh6Z6VK7MlGmaBdGEiW8rILMdGegA7SDtPTCjFdWxHXKD0LoIWheMFCFphbge0t6LCkMYSoSu2Yl63XxwKoRRJIR97bCnAHYR9U9vQTqegqAc5hkfe1YKsWIQgvVEH97qflTcQhcCdIAJ1ImgukpmkgDDW//RoxQ2D+IXBFFmrgoRNv2ij2ijTf2S2NhxeSGFTXmevMslGlfYhWBMca2YoWA5alj5UZWvQeM0C1EKK26RmumgHVPDNRqWDamG8vXwfWg9cB2NKl5BvPJsmfH4P8CNSqnPA08BP3q5O/pHsGUqxpVEpEdE3ici8yYz7Ac6brkF2trg/PPBdc3je9+DBQuMAR/KWabTRlv90EONAuRoDHzz21As8O/p/+LGhssoSoxb8m/hgXvqea/1DW6tO58pVrlISCus2qjRRwl8E1+PJIYTl8PQguS6oLUJRWgMuwhMWzymulRCgULeGPbRCEJYt8eEeUZZSBExVMmVj5pvtWU6tM1HLTkZKY2zhkOIJBCJseebDyMh2AFY2QAVYPYxJQK9/kiCsgy3KMawj9td6Ao77xyb0JVQkN4ShfU5klaA2x8QjulxJ0SdEG0rdIXEp7YUTTMtUNCwOEqixTbXuAylIZpUNE7TEInBOW9DJarhmNcEXkG2zPAuRe4XkfPL/28VkWNEZL6IvEVEJmFBvDD+EZ77bmDmqOcvOa6klLoAuGD+kK7tAYCf/xw++lGjoz5zus90vYtp7mbetfBu3vnUZ+jpifHYJjjudWCLMLW5jz07PAY6+iHTBYnDwUoR7t5OckYCO+Fw3OWHctoVLRDpo/D4FvJ/0KSvvA5dlyLM5XDe/inwM+UOEsrEsJ9YhXR1Iul69Nx5UJOEvtBoszREjP56WcUQe1xxzXijPhrFAHJdiO9C7UxDNs/0Ig/9FXq7IWYUs+THPzE9/Oa0gh+CpZAwNJNIzRSyW4qsufB6MnuKbLWgbY5i9gKNqkuhpiXxO/uxBrwJHoBXGhn2eJQ6fNAOBB7iBrjPZcg90IvyQuqSkIxrcGzyg6aqtXlpjEQiJPK4njRdpcUcS2nF8vfXs+V7XfTsMz1YG6Yp5q6w8QohkXdeiz7zn17kXVLFqwJVbZlJ8TiwoFyJtQe4DLjipexARG4Hbj/qqKOu3g/je8koFODaa2HGDEglAr7Y8HH+Y901dMtcTsj/lpvm7eKyjd8HYMsWWJRfxROrpjE44DB3Vh+4W8DbhbdpCnE1iAoDnBNXEH/HOWAbTzx21BJiRyxBJ034QaTWcNoDDZaNeB6s3QF+gDQ2o48+EuWYr1cSMZRqMSHz0TIHhUFIjCq0sayJYZQhtDQaxkyuEzY8gQwWYcPAiJdSCiCzc2T7Z7fAYAnq0rBpLxL4ePnNPP4f7biZ0PQT9WHbZmGg22Pe/AGSF56Ad/ezWN6eCeOIJaFQaVwKamfaqNefA2j63vczgi2mv52yFW0nJHBSzpjtaYogCGq1NsJjlZCwhjn4lqOYMTVk2hShZ0+AmxF2PFDCmTWT+WddWvnzVbwqITCWPHAAY7+GZZRS/ws8AixSSu1WSl1V5nB+EPgjpjLrZhFZuz/H8VKxdauhJL7vfaaLUaGiVRnBbbfB4YcbTfbPnn8fp8fvJuOnKIYR/th/Kkc6q5hvbaQ+HdLZCWuebOfRVU2s31TLW9+8FRNU9gg33YUqhz3iH34LSlnl2LlCR6PDhh1MGzkF4KRMALgnOxwj18sOHTbsI9sKynIQpZCmVhNb2P4UEvgjcrQKqK0De9Scr5TJ8i5pMePs6zX0xh2j2ulVaho8xCoYGByumt3zlxxebmx3o1AUPf2aUsan8MP7NDFSqAAAIABJREFUib/vVEqDo8ZUhuUoYmUZ3ZGxgRVRzLrmMEDhPrVt2LCjwU5b2K1jpQ8QIOujbQ22QirNZRrUEpOkDd2Q4uMDhIEJDbnFcnVvPEbLlz5d4cNVvKohQ3pCz/84ELBfjbuIXC4iU0XEEZEZIvKj8uu/F5GF5fj6AdP0Iwjggx80Wi/9/YbG6Afw5FPG0PuVG++wdSvMm2eiGie6t2O7eb4y+7NkwhRXb7uO2/UlLGvaSkQVCEI445IziEZCPvvxp6ivc0HZxlDNSqOmptDz6oEiIgHiFpBixsS6J9w1ZZHx1FzIuaBtqKs3Sdah98ecoIt0dYGVMHTHfD+y7n7I9iChjxJBJWKo806HqVMgnYTZM+HkYwx3HaBYNJNJYdTFeL6beZSX07uhROhN3FgryBUUYVcG3ZzGzYYUBwOosSCmcaM2QVOUaEoTr9PEGzSRlKL50BgrvnEc0aMW497xCKUf/wGd1OikRWJhktrj6yf0ZAWgzH4REcIAfMxKW4BAgTc1Thh38Lqh+JRA0IJ9ydspHXIS9rSpJE4+nrZf30DN2ac/z4lX8WpF6MsLPg4EHDAVqi8F+yvm/olPwNq1JnQyXD1+E8yZDf+52cTUh1gwo1FfD6tXm/93xpdR33gvb75qD7X2vXzwM2dw1ROfw/c1l8t3zEYifOlTj/DOt+2D9HzQNhIE6Oh6ai5qMbPMH2+G08+HZCM4SVOEhAI7DlYEKfRDrstw8nY8glowveyFGkkBsU0zN1WuTJWBTsj1oWIx0CWjStBQj2zZC3oLzJkPEphlZ7EPkiVIaAh7YWe/YcrU10PbQsOJf6YXcuWm1M9XjGnbEI2BVyIxPYJaW5zQl1SAiAPEHKTkQygEUQt1aA2yu8jgJo+Nt+dZoQLiKcWKky2Ugr5Oj/7rHyV66JPYDQ7OwhQsHEuLlEphF1sND9svhux5LIeyIFWn0CmL1KIkfp9LtnA4jdd/HR03K6YKhMsqXmso52IOBhyU2jIicruIXFP7Cgoz9fTAD35g2CvjZUEsy7z+05+aAqPxeNObTCPqtjb4zKrLib9pGvZ5Z3Hu+d1s/sV1/Pa4f8FRHpYlpJIue1f/jHdesR3q5oEVMSGSTX+Bpx83FJswRJ11ISSbUE6i3AnIhGcIiohfgg13GMMOJpEpPkoCVOvCMmOmXLqvNGJFTaFSImGKjspthcRxIKqQR1aPJFOLBdjynJlghrxuPwQvQNrmjhQ7HbZwpK2eUmMKiYahFdTVoo47A+I2s86uRdvjtxOiESFZZxF74xGUfv04RDSx89pgZh0qH9J4cg2pBkUibQS8LNs04aifommZY1HMmbDQ+FCOiEC+gq5NykIC42ENtUyLxoAQwsGAwT90YyWgruUZOv6/D092y1TxmoSRd36hx4GAg9K47w/cdhucdRY0N1d+v6EB3vAG+O1vJ77X2grveIfpknTvQwm++vg1YFkoYOB3a/ni2qtY0NJBEGiWzO/HsgTiUxh2eYMSsvbJEV75zLmG4+0kjOEfDzcztiPSkCGP1YC2JlIhBahtmbAbJQJ7+2FgELn9T0bgq5CrzJoJxPRELVexsng2tMbNHaQxXn7bNDMTOrapUK2vQyUTMNAFSpFodVjxsVZiTTbaUSgbaps0i+aGxM4/DJJRSr97nPiFs4ge2YyaUYfUmW0POT06YUjaMuft1GrCPg9KoVF3HHoUA0LP/NjCwNAopcYCW1Fod/H6zOQYiYMTGTXphEJpQ950h9ryV4LevonXo4rXJISDJ+ZeDcuU0dcH06Y9/zbTpplYfCV89avwz/8Mmzf6fOIHF/P5X/q0NufZuevd5svWiqWLekkmyt62FR0x3IE7Vougtr78nlAx5hEGpkhoPKzKuuFKa8SJgj8+Bh8YlosAe/ZBe+dIbH08hvi9Q/sEaIkhzVHTB9XRqMNOgnSLkQyuSaEe+LzZuJAdPovGQ+Kc8q2ZlHoDlBK8h3sI9mrigzsJD5lO7AtHo4blFRWSttFaYevKRB6lwKl1oN4hbC+itueh1mHPsy6DO1xKGUHbijlH2nh7iui4pu7q2cQPiyD3biXsc4nGxouTQTjgo2yFXe/gd3RiNdRXvi5VvLYgBw9b5qA07vuDCjl3Ltxxx/Nv89RT8J73lMew6X7kiRsh3w1Tp2IvPYTr/3s2H3l7A9d/o5s7n3kdvX0x5jV1cNHCh/nPb3YS/eeC0Xop9iP5taj0FBAPamairvgosu455KabYdW9yJyN6DdfiJoztvJRRKCUgdYlELnPlE7ajmGkuHkqTQbi+0hh0HjqQxYyDKE3g5paC9MbjFH+fSfkByufvNawexNi2Ui/A49thWwRZjWj5kRQKg+bVsHSE1F1Y5c/km4mdDdgRYzRVi2ziB1/GETiWEu24t18LzLDJujox90a4kuE1LHNUAyQjhLS60KsnDwe7xYJkLLAUmgPEIVYikToYaVC+n2F60Fhe4HQDdHFAG9zjujroqiERVjJKbcV9rQI4guldh9n9qznvzGqeE2hkvbegYiD0rjvD7zhDUbo64kn4MgjJ76/erV5XHghhI/dAI//YridHdkuZMdzcM65LFiY5L/fuZqvLFoD6VoohEZ7pZQvh1JMRkaRBamD2nlmH89uQK77Prhlj/yZrYTPfRv9sfeiFpW3EUEhiA4gmihL+IqhKgY+eAUoZZBoTVnbxRh2Mjm463HkrGUjpn/zdigUR8I7pbwR+ErVGkM+OjSjgCl1qIhDuNWHB54xIl4A/VlkrYbTW0AyqKf/hCw/A1VvwkAShHQ/Mkgq7xNtstELl8OCI1G24Z7bRyzDPnQxcu8tRPwC1ENYCun/4y5SEqIDKSewVDmIqMaOq8aCqDarhx4XIho/F6AKAbEYTJkiFLIBYcmcT+hD72/20TwngeModMICR8EQi0eDjmui85K43QGJyz8wnFCtogoEJDg4PPdqzL2MSMQwYS68EO6/f8RBFKB/AC64AK67DqIqB4/dMGLYwWzseciG51AEqGNPR/JTYddOqG8EVSonP0fxwgmhdu5w4jP82c0jhn0Irkf4i98YIx4G5m+hEyWBaVo9tD+tIRYHbSEdW5H2nUgmiwxm4an1yM9/B50Z2NuLlEpI/wAUS2Pj9mEAnmcM5knnQ2OzmTQsDVMbUDVxJFIDD6wdMexDF8gPkU2DxuyGAfL0g0h/Bim6lHb0svVDt7L2s7vofCA/xrADKG2B7aAWHj78mo5q0gujBLsGK7a1I6qMQW6wYWYM6XKRtVnChEVh0Cf7THZkXxoSNWP3IYHQ/Z1tBJkAqylK4uyp6CkxdNohtixN3eUzUPNaCE76CA0ffN+k90wVr00cLAnVquc+CpddZoz8NdeYvwsWwL8/bpzY626At7wFZO9Wo+ESjGtrGIbQYZQBlfSiDrsa6bnRhBL8PGP5U4KZV43RkTCEve2VB7WrA9yydorp3mz+d3Njt9MaYjFYvRXWPjmRrWVpyAnEszCYp6KOLQK+h26aBq+/hNB3YeWtqGSZN5+TckK1Apexa5QERpDHe/91hOv24BYEIjUEeaF7taY5H2Cnx3ZMUpaFNI3rSRAKbqipmEVojaJqI4RdJXJ39xJ701KcqxbSd9VtSK6yps14KfsgE+B3l7CWNpG84jCS42ukdYzUwknluKt4jWIooXow4KA07vtTW+bii43W+qOPwr59sHC7ia4c+5byBsnGyslMMP3yAHTZGKoY4Brdk7FnwBgDqZQpPMpXKIUdMqzjYVVuKUey3GbPH2eAtYJkzDBtHMtovIfjaYJqhA0D4Lngm2pRw8bRRkSsEuKjbqVSgITCeNVftzODrlBUJCJQyIwdia3QMklCOWohboCUQsJQoevjIKAdNX7aGXWMCi9aGsGqTNMXH5xqq7wqxqG86D4YcFAa978poSoCxc1QWAcIxBdDbOEIcyXsR5U2cVzDI1DcAGwDt3HEwCWT0NQKXbuNEV1xCKomZoxlwUPWPGz0aNXtEE9A2wpI1UOxb+I4Sv1I1HRNUuecitxxj+G5DyHiwFnHmU5KOoqUeo1xtiKQqMDZVMrwz5csRKWbID4F2bcd7rnPtKari8CzXdDWOsFmCmVqZPcg4SP3olYcTWFTN4VH+mg4J2noluSRWc2wvXOskbcUaqFRRZQQqKnD+lAr+vGd2Fqz8F9nYCU0vQ8PMvjIVtLHz0VHR01OgY9sWT08JBEIowkSZ81BHtuJGh/jbI3Bzjzu7iJ2XKFXTEfyLjbBBOMuYvjsVkSZRtyBEHhS1lpTqESzEUELR113ZUPNAlSkYeI1ruI1j/H1FAcqDkrj/jdh4B5wtxnPDMDrhOIWqDsPgnbEfRoeugkyvSYE4mbBy8GanyCL3wjdN8KZF8JDv0fNrQPEGIZAwBIIS0aMRmsTw970EMw+AhrmlWMDo7zRrmeg5QjETqIuOgvJ5uC+h00IJQzhjBNQb7oYURqye6BvvbGesQaI1IwySmUmSSxtJqAoIBko5FDzlsGcpchzf4ZVa8yE0Vhn1CJ3dyBuyegqFALIeBAIcuujyLZdxM9/I7F3n4VseRaiAmERTm2Duwuwe9CsBpSC42egpkbBLaFmLQdVQg+2o5qjxC1FfIWp7UzOiVHa81eC3Q5qdlu5c7XgPfIgumMPOmpYL6oujT1vrpGDXzgV+eVKo12jgJgFu/OUNudxc1Dzidcj3Tm87z+KtjV2MsR3KRd8idmfH6Btk9sQbTx8VT+dSNiKiiSRmZfD7pvNtZUAahbD3Hf/ve/MKg4GyIEjL/BCeG0Zd68TStswaiJD8MHdA+5ukI2wdwNke0di22AM8ubboMaH5ja0tpFlCyE3qvtOueqT5imwc4cxXJ5njGl/B0w93Ih8SWi87uxeqJ0DmZ2oWiNBYL3jEuQtb4DefmioQ8WiJkkaBtD33EjQuNhbXgmICfnEayuTwCWE/o0w5Rhomg5qDcybZiaPRAyOfT08vRG5ZxVk3REP2Qvhqd1w+GpUUyNq/jyjOlksoHwXzplvtGWKPqSjptjHcmDxOSg7ghQz8OCNYI0dkxXVxFsF1t+DbIoaLfTcIA5CWBODhfNNGz/HePUKkMY0nDqHwRvWkxwMULmAwqY88SkO0UNSqPvXINkidj0UdoZoNJFmm/hlbRBR9P/3xvLXo8b8TZ10DHrV0+a1ptchjUdDqQusJMqparNXURkHU8z9tcWWcfdQOWDmQ2m7ea9jW+Vko7Yhu2PkeaG38jFsayRurbQpFKoxKowKTPVoaQAQsCIobY+pQlXxGGp6KyoeGzHYXoaJsedRSo76eeZov2iqXVOtkEpAXaps4BTYUWTjPsi6Ez+nNezuNswcQDkOqiaN8o3WuorbqPqYMexgJrOhdkXRJBQq9xhQWhlv2iuhcgNG+wZQdXUQjw0b9tHXU9WkkHQcQiMXkJoRw4paqMEC5EoopdAxjRqqMs0G6BrbFG9N4mW5Dz04dlzKQsVaq4a9ihfGK9ysY3/hoDTuSqkLlFLXDwwMvPDGo6FjVD5lC6wEIBBLMKkS1mhDPJlBHT21DxUN+cWxVI1RCdYXFb/TEV5+FkcZbq5fBM8flWgtKyDVJCbXcI85E+UP9GS3jIycl0hl2QTK51vp5vf9yq+HIeJ7hFkz4arJxspY/rFytKFLTnJ9dW3dpPupoopJIeXo3Qs8DgQclMb9ZQuHRedNYsgUxJeAqoO25SY5Oh52DFrPADdr+obWzmLCJBCGkMuNxNW1Ee4iO655cmq6eT3fae4ELzfxjhAxEr0SGo0Zp5Im4Wghi0mEyRMt5px7txpvencXMpQMLQygjl5iVhvjEbFgwQIT7x+NRGoizVJpqJliQjJhAL07oH4SDUUBvHDipDYwia6DgGRz+BvNRK5TVkWBsDAfGgKSpbCX1KAcjY5YWKkKk7DWxK+6pvLxqqjiBVDVlvl7wesAbx+oKETngh4RmBKvH/ruhyALqUMhuRxVdwH0/4GhuLuIQnqT8Nz3wAJVayFLT0Gtf9A4oL4x1JKcAaVNqJopRna3dp6pCB0sdx8SgWKRsL2b4u4AUTY6JkSXNqDsCGy71/DVlWU81EQrUuiC2vkmvi8+iG3+z+4zsgbl3nKiNUTjIwnUUCDRNOzRi45AMFJUpZQFdhKSUyHejOxaCYNZmNcGiRRYcYQSqtiPqk0j7zgTlQWeHDBVq3VJuPw0qJnK4OpuUsta0bEESBHR3QS7+rFrypWjlkJci8IDA0RKO3HaEvjrnsJ9uIt4IUTF9JiiDsn6qGwISY2MmjckEkcNDCCpmhG1SRHCZ7fS972NaAGdstE1NqFWY/fpCvm1WSNjnLLwYxbevgJBj01sVi3FTX0ExbA8/ylil72V+Jsvhe987xW7Dat47eBAKVJ6IRzcxj0YhIG7MIbagtxjUHs2OK3I4BOw65dmOwmh90mItyKzr0U1Xwl+F7JvLfKHL4MKQJf7kFomZi7HnAe33W6EtUKBARfVXObVKwUWkJgBG1aapKkTxbXnou0s0SU16KhFWAzw9/Wi50zHdqzytO5Dz2pE16GmLCtL/pabg4oL+540nn4hN6ISObTaaGgxRr5xIQxuK8e4BRUUDXtGBNwS6EZomjvMzlHTV0D9DGRwF6pmmmGEDGw3YwlddEsUWrUp448m0R+70kySSlG7LAkt8xlaGaj0LHTzIuh4AikVy7o2ivjJAX0fvZ5wMIsaMBOn014EBdk7O6g7ewrEbFRjBBrKu8sUDKMFUJaPbN2F2+WS2+bixDSZRzpxN2SG+fIN2gw939ZCxPJh1yDuc/0EXS6+JwTZAOl0YWue/B87TFohZpP88LXgeqjmaUROPRPdUKU4VvEyUZUf+DtBPEaYL4H5f/DPSODC7hvHBsAkhEI79N5tNM51PfKHrxpPWIdltgumsMf34OHbIVNuJWdZqHMvHJYKKKcjoaYRYrWQz0HLIoLnVmPVOlhxG6UVVsLGboziPrNrXDhIoRrbUFZkzP6UUtC6HHx3xLDDyFqvrwtqZhvDPqZrgBj+ux2FgSI0z0Zpo9uutEYpjUpMQaVnmJBTvmOECjo0LgmNjjyg/CIKZaQB4nXguyPnbjmGn29ZqEQSFYmg4w4qGSX17qNR/d7I+QBKIFjZS1AAZdvlMZX3lYqNXMuSh8LHiYUM3Lyd7h9vpbQ+i4SKwDfzmN/nQxiStLM4MyzsBTFiy9M4MQs/E0yMdQoEJZ/Cd79N7O1XE7vk0qphr+JvglCNuf+dUGEGlQAyj1W+whJC/yrz/95nzF9LVY7DhwHDte+JROVEoragdaHZPNZEbPYo9sjQJo4mOn2cFrmTACtW+bgAkUlyCRIaA14xvm5i9NRNG6PdMgZWzHzWzVR+fzhpK+CX5Q1ExlI+AQodE0agtCLY0lPxnJQCb30FtUmlhkMwCiBigwixWeOrctXwNx0WQqRYTq5GNHpaHC8fVLwVhk4lKPl4Kx+aZIMqqnhpGNMzYJLHgYCDMiwzLD8wZ5LOGlVUUUUV+wNy4HjmL4SD0nMfZsukkxPfVBbUHFOZiqc01JXFoKYtN3+DSdLb2oIh+nc+X7k7URhAuymS0cVuituLE+JxoRdS2jOO8+3lTQJ0shnenYTiqTT4ZZnfiW+a+H3/XsSfRPsmKJrPRibjcg9dM2USsmC86+S4Lk7xlgkjkFCw5jdVPCcRcJZU0GkRGZYxEADXB6Uo7hivsSPDKwUd16hyQxFxQ8K9BZyENSl7FQVW1MY59oRJNqiiipeCF8FxP0ASrgelcR+GchhZfNjmkT4dZUVgxmXGGA4ZeaUh3goNZ5qnVgR17mfMPsKyLIBgjLrtwEkXQW2doTMGAfKHW0eWXZSNUaYb8n1m31ufxFp6OMGAR1DwkVAI8j5+T4nI8pnjjJ4g3TuRwB2zPxGB9mfM8a1R9MSh6tf6ZsjsgPQcRqLamL+RGiNo1lgDezcjYVAeb2ge+S5kcLeZkBItZU76KB640iaRDIgdQxBDayz0gx0ZOffAg2g9SkD80LSwK3hIrkT2RyuROodQRi6nAF59DCttGTnU0cvXbGnkWjoWUgoICgE6Zo0UJJWnEe0o7HqTy5BpcWSwhOQCvCcHUbYmUlthEVo27MkvfwOVrLa3ruKVQZUK+feAlYbac8pUyBhE5wxTIVX6SGThvIlUyFGxc9V2NFx5M7LxXujfDpZGNc6D2cegnALyoXPgljeZzkcNNUjXZlTtDBN/lwCSrfC6DyB7VkJQxAlcwgXHUFq7A8lnECtBbFE9lioiboAaqm3KpqA+iXRuh3gNJNKGXukK+FOM517fYFYhIqZgKho1omLd7bBvD7QdYZKbEiJFC9rboa4OauqgJgK71oCKGC+ivxviDugiUthk5ArCGPR2G9kAFUK6DoWZUGRgwOjjdHQT2klkUwFr3v9r78yj7LjqO//5VdVb+/W+a18syyvyItnY4MjGNoEESAJMCAZCEiAhZJmcIecEMoRJDicBziRzQhIS4hDGcPAQgyGAGSYO2BgDwY6ELdvaLMmWZKnV6n3vfktV/eaPW939uvu9XuRutV5zP+e88+pV3Xvr1u3qb926dev33QiMoQMdyNgQtLUDE4R9I/gHXqJwpIuaOxtxN2whN55h9OGTcL4bJ+3S+ivthKMxAt9FC+OQyyMeuLUxEJdCX55sfwF/zCfZkqL1v11O/tgQ+VNjaOARa0mQagXnwWGIe4SD1Qw/M4r/wjjpulq8jetI73498Y7z+PsfJ+wdhFSKxKvvJvXr78dpssN3luXBRN2+RNR7ASpb3DUPTg6NJSHbA32HIOuAH5oAXnSBZKFxF9CCPvHXaOfT0LwOdu5FarfDqWOET/+Q4OQZaKzBvaUfTj1N7qlzyJl+kmP9SE0Grnul6TX2Pg+dpyEUtKkZSWegroZ8t0vf9zoJRrtouLWF9N4bQTw49yIMZqG51Qi440JTjRlCSTZGAa5yZr2fh+P/AR1dJvZL4wZo2wy1GZgYgngaNrwCxkeh77TpqYtjolQGOeg+Yz7ZADbvAC9njt/Jwtg4OGn0XD/5J39EIQ9Oc5zU9esQz0HPv4QM9UEQogeegg1NSHsDTrIOjh6GHz0FrQ0wMIK+1A0j+6ApiWxpwq3zCOpi+G4cJEm8Okfj65twnq2CZILw6j1I5xBuMoazqQ38HOHJ43C2Ax3I43gu6YJveusqBBMQb43hOhnGD42ifhoR4wGrhRA9PkbttetwbrsRTW3G2XQFXHsryVIvn1ksy8yl0jNfiMoWd/KovmRGJ1ICsQZ47D4Y6p5OUpOGzmfR6ofgxdPIDXuhfTOqw4T/+KcUvncQv296TDz/VYH19QSnB0l98B6k4SiIia0CCocOwGAX8jNvQFIZcF36Hn2RQ7/6JRBB/ZCTImx6/y423zAEiRRyx1shlohisCtSt8EI/xQK/ihkh9B9x2BLCtlxF+y6wYh/GERWelnzctPQCajyzN2DBvD4Q9A/xNRr/45AWx0yXoBDB6NdmHn8smEH8fe/l+F3fJywa4DR9PM0fHCneSlJFDxBGIQTPeA7cGrEDBFpgB57KdpHVO0zwwSdOZyb20neuRUZHEU7zk+HA/Zz0DMO//qImZLpeXAwDb/zAdxdt8LhZ9B/+zoOIdKShOoYiEyflFfGSV+dgmMj6OEBZNT8nXS4m/wDL+BeU43XkCB8oga+lMD5yH1IxoYVsKwsWvYBz6VFZY+5g5nDHX3wYnDTm2cmGI4eho4Mwu5XQvtmM1XwwBHC/UeNsE8NepuHdMGxXmKvvIb4HTdMz8l2HDN3/NW/gFxzM1TVIrE4YTbg8Lv/hXC8QDiWR3M+YbZAQ/UZNDeB7LkLkmkkFp8eJRdvet64iJlT7lUZJ6XrWiG2FV5xPRKPm4BdiWRkR5eCcz8Bz2PqoWo+D32DZl58GEZeqgV46ifooYPmd+BHgb0C6DiBkztP/V/+Fpr1CQcmGPrsMaT4gbGDCT9wdsSIue+jqBn6d6brTcLBGZvAGcghXgI6uxBVk8YRE10STJz4IIBcDoaG4KtfQ2JxuPIVcNmVSMqFTGzmnH9AxvJIa9rEb2+MTf2N3M4JpC5OcHAEjQGFQeg5Q/jFT67gmWaxAAuMtV9KY+6VLe6zLqAiDlTVQXrWPPF8wQhTw/qpOeD6H0/j9+fmTDyZHE+L//ytSLqEMbLjwqadSPTAc+CxF0xPuYhYtUNVu2f21bjOCHNRpecEvxIBHPOdn0B23YQkZs2NnyRZxYxK5wqlZ/IU/NLrAx9OHSR25Uac+gwoFF6aIJyYfmlKRMBzoGr+YQ5xxIQXODUEnV1zXZpKjU2GITz/PBoESDyBvOIGI+ylvFIBghCpTyBtRe0hgttm/jZBZw5qXKivgf2PzFtfi2U5qBRxr8hhmal57tvXl9iqpadBmpzTiwtNV3LLCJtOlmPyl3wVeWoSi5SfolcOZTq2Ssl9L2rlrIrMzhKabLLI9ljoGJZ6RhenL/u3YvrQiicGTW4QmZxiNPl6b+VMQLZULIoQhHZYZsWYjgpZYnpbdhTGZlnaxT2jJ0OdU3PA5eZduPWJub3/SNPz//YEOp5lLgodZqohQP3ebag/U1QKwyETPQFayEN/tzHALs5fUgijdYkk+sx+NFciHroI5MaYUel4vPTbs16Zud+uB5uuwj95nrDfvKnqtSdwqqav86pqet3jwYyqzalxqGhekc210NYy96LklaiACGzfjngems+hhw7AmF8+GJProIM5tKso5nwIQY+JW+O0JWEoMM8cdv1M6TIslmWkUnruFSnuxWjUW1M1cb/Z942ZCTKRv2lNHex/Avq6jOjedC3OlZtx6+MzRNBJuDjrqyn86ACF/UfRMIziSYRm7vgT/xd99seQHUcLebyaJDs//Us4SQ+Je0ZwquJ0v9SAxOLovu9AIWfqJhJ1NoOpV5Q1OhvUHzNZqRS6AAAcW0lEQVTj5wd7jcfriWNoLmvmgxcK5gLhj0PrdVHcmajSiRjUZKbvNBzXCPgrrkWuutr8nhR/14OWDWjdZgY+eC8kXKQ6Tt1vXGYiT041KlAIoLXK7MZxkJCZc9RDhYISejG0OYU6ITQ1oiLT22OmTJ1s33jceNC+9a1oPg+nTsDzB9FxHyb8mXP+Ac3EoDcLPTnoyk314MMNabQvh3t5xpzAyQaoacR514de9vlksSyELuJzKVCRwzLTeIi0o+EoZHth4Dy03QxNNxm/T7rBC6DhaiR5PTrwRXT/49C2CdlxK/JfP0ryyAH8H3wf/6VupLUG97YtSFOa/JNnKDz+A7z+AaS2Gg0DM4qxdQckPfTYs9C2Dqqqab27nZpH3kX3w2cJRiZo/Jl2am7daYYcTj+PPvM4rNtmApI5DvSfQhPVkMgYwQ8LqJsCzcFVG6CjG33yG3B6O7JhO5pJQTgMqSSSrEJjbchIp7nNEIG9b4TOk9DbHcWi95C6y8D10ZsakYF+I9aJOsLzo2Q/+WniW+Okbr2c1C3rcVIJc8ejGA/VXBrZ2ITUNqG31cORwzAyiLQ0ooOjcKbbPKhuSeNe3ow/oPhPn0Dqk3itbbhhHoZzZrpnQxx+bi+cH0KTKeTyLdB5gvDHx+HUC2hWCQV4YdS4OzXE8XGMkfWzw+SOTuA2ZEhd3oTzzDlz4yNJYj+7Aad5PcTXI5uvRfbchcRLPCOxWJYR0xd7+cMyIrIR+ALQhgnqdK+qfkpEGoAHgC3AKeCXVXWgXDnzUdniLklwt5uhlBiwgEOa3P0XM367AHtuILbnN5gdasu7Ilr4we0mb9Xrzfdlr4fL5padXg9bbimx06ai5fi/mu9Nvz838BZADfCWX51b79m/W6KF5BPmd+t7YFaEgHJ5XaDqjaXT8onbTZp7HpyZf2eZ9EVllnz8+4WovNf+1dxtN5Qvr/iknDHw9hNTXuLvHpu/QhbLCrJM0QV84IOq+pSIVAM/EZHvAL8GPKKqnxCRDwEfAv7oQnZQ8cMyFovFcjFZjjF3Ve1U1aei5RHgCLAe+AXg81GyzwO/eKH1rOyeu8VisVxEFAiXYVimGBHZAlwPPAm0qmonmAuAyNR9+pKpbHHPD6NDzyLpdehEr3EhwgHXQzUPnUcg0wRjHeTPdyM12/Da63EK3aik0eEeNBhHajKEwznCfANeXR4RhZQLEkfGz6MFn/xznybs7Sd0FS+eALcfQkUStbgxDxkZhZwPDWl8z0XcBOFoAaqTqFOArgESQy+CI+S+/yFIVCFNDYAPvR2IxNCqGuPB2twIqImSWBg1dnrJavOAslAwD1SHhogPm/Lyz/yJsedzkqivSHePKSuhSFXazHnP5aGpHkIPRodM6AL1oL8bMlUEo6Mk+46BOBSe/DCMT5gx++5RU6eka4KJOS6hH0MLBeKb29AwS9iXw4nFEDdA8jnC8XFIecQ7D0IhIP+Fd6Kug+OG6JksvpvG2biBWG0GJ1YF8RpjrzcyhrN+K1K3EandiBSZkOv4gKmz40H3ORMLJ5lerTPP8lPMImfDNInI/qLf96rqvbMTiUgG+CrwB6o6PJ8B/FKpbHHP9sK+v0BjKejrh8DMuCBTB4e7TeyZahfat5K4+dUw9hwUYiCOeRuyzgEcVBy8LU1mME1jqB8gzgSEg+CFSMwhsaEWNjUZC7zhM0x5v4WDoCFaI/BiB9oxRGxjq7HeS9USdjaT++uvooOj6MleSCdIXHYd0tQMCOH+n8DXfwyFyBv16u3I3Rmkrt0IGZjok0M90HytieYYix4uZL4BYYHE1uvMBcBLmpeErhLI9kN+0Bh09JyAbTdBVQug5k3VweMmQNmGFpPWj0Pa7C/RnAC3GvDQ7AFIByCTLzkpbL8MqW5mal6AKoz1wfggkEQn0vDdI8iYmc6ZOHAUNqYZOzTG2OO94AgSd8i8eT2pm5oQtxnNtsEL++B4NJOooRG94h6kfQ/67T+DnmNI5yEIlfDDvwhjAbzml3B+44/Km5NYLMuNLrrn3ququ+dLICIxjLDfr6pfi1Z3iUh71GtvB7rLlzA/lT/mriHkRiEdMzZxqjDUD/UYYa+pR/a+HsZOghePwgAXWcupj2QaEddDYmY6o6TiiDdtAScKkh8x+xk5a4R9MgyvY+4U6DgPgwPItnWQiCFeDE1eQ/bPvoB2D0C+YLRwPEf2j+81JR87Dl/5qokXX/BNj/zwC+h3nkG8hAl34LhQ3QTrdgAOEquZDrkQvbAlXtJ8RBDXNaESUg1Ios7Eo9m6F9LNUT7XhESuvwJSzZDtA39W/HQ/a+4EwhyS8KbexTKt5iPnzyBRhA0ByI5Ewh650Dx8GHrHpssLgNPjpG+oxqmLga/oeMDIl8+QPzqEdp2FQz8ygdPCANEQBvrhyBfRL70Puo6YXjtqztgrIqPwR79OeN9frtipZbGUYjnG3MV00f8ZOKKq/6to0zeBd0fL7wa+MTvvYql8cYdIZAVipucpjpjAWo4gV95sAm1NStGc2565tnMiAm5i1tuTCgMnp0W9aN8mDnsP1FTBZNyVuo0UvvlD8IMZZaMQdvQQHn+J8LuPmmGWYvwADh1Hx6cFVxwX3DgSyxRdmBTUeJ7ixOYelziQqDNC7qVmhUCItiebIvOPEgR5c+FqapvdWjAxgmbHp1eO9zPVi+8bg+Hs3Mm+CnIuS+qWIg/TvDL2nS4Yy89NHwYwMGAuHLPfPBWgJQ75LHz3QfPegsVyEZh8KXoZXmJ6FfAu4DUiciD6/BzwCeBuETkO3B39viAqclhmMvzA9nWznJhmxydxBGqbIDgzz2vuijHaLrF+dp4gbzxX51bIxFWJedPx4mNp9FzvTKPronppVz/S31+6Sq4Lo2OQnuUlKsUCXXwGlblNFNcIf3Ekx6kqC+rGS+eDaUGNlYlxU8jB5Jh3WHSMo7kSF9CIfIjXPLO8oD9ffm5ZdAGbjbiCppzpNGMjUNdY7kgslmVlOaJCquoPKR/Y486XvQMqtOc+GX6grmqWOBX3khUTm/zcixCvAS0hsgAIuLMNmaP14aw8ZezpBCARh4kcOhk8a6IfZ9dl5g3S2fgBzuWbYdvWMkKoUF8idG2YL+oWFOcrE1MlLJhhmRL7UA2hMFYi02TxkVHIeAkzbRFIFV1YvSLBbsqUDlgGUOWSf6FonwLxrVUmSFkpPK/kRVn9EIaNSTapKqipL38cFssyE4QLfy4FKlLc56BqhH3SjzNU6Itu9Y/th/RmQIzAl7pn8tJT4QBMcYoWxpjROxYH6reYnnhxGZO9y83rYdSMnWsYwnAnsTuvRTLpmUHIHMG7cw9OSz3Oa+82r+QXi2/Mg7teNUPwNPBhtH+6ThoFzhJjizdT9CczhZDtNSI+MYCG/ozjQwNjcJKooWQHwoubMnvPzywWoKHdbJ8k0zRVhmQSsK1pbpwZB8K2FNn/jF62E5C4Q9XPtkFteu4FyHGhphbar5558VCMY1VvARJJ5N1/OMNdy2JZSVRlUZ9LgYoclplCHEhmoLoNzp0Et4AmktC8HvpfhKFhqA4Iv/1FZM+dEMsjwTg4HioO4pi4MjrQQRikkUQanSgg6RhOwkHFi0RHwMsYs42mq6DrkBFfAUIzBi919YSJETjaiWysR+uqoXs/yY+/ncI3niV44hAkupD6NPH33on6OWhsQP7g99BvfQtOvwSZNHLbjcjmDIz2oqk685Bx4BykmsCJobl+cKtMXVTBz6ND3ZCqATEzgShMQGHYPAn2Azj3CKzbhdZuAvEgNwDDp6CQNWEJ4jWQj8IPiEA8Y545uAnUqQW/y4h1CEG8CjeVNKEUvCjGuuNBdQtMDJj1r9puHnB/5SigUOPBujT5QyO4VS5h3CV2RT1VP9uC25xCWq5Ed22B576PDvRAPIk0bUVu/H2oWY8+9QA89y1wjkAgcCoGO3bh/PL7kRtuW8UT0PLTyKUSGGwhKlvcq7cgt33OLF9nvqauma+cP6vMWi7b94v9H/Pd8M7pdWVeK3CvWmD97beb79Z3Te97E/CBt89X1bL7w2007/63v2f+/LMjI8cpHaoh/SPzveUj0/VbNzPJYvrIAuaVjC/cbn5/7DFTfPQpm2dL6eOQPe+EPe+cDmfwT48tohYWy8pgxd1isVjWIBWi7VbcLRaLZbGYeRqXxpj6Qlhxt1gslsVyCZlxLIQVd4vFYlkCl8psmIWw4m6xWCxLoEI67lbcLRaLZbFMhh+oBKy4WywWyxJY7njuK4UVd4vFYlkkkc1wRWDF3WKxWJbAJRI6ZkGsuFssFssSsOJusVgsawzFzpZZMiJSBfw9kAceU9X7F8w0dIrwxN+AuEghC+mkifDY0Yt/+CBy/TU4LS2I5qDzeTh7GsayJs57azts24kI6FA/2vkS4oJUN0HdOmjebIJzFbqNBV7nVyIDDAFPTGz3vlPkjnRCw9W4LQ04ziBOOvL59JLGuSnMgfrgpSDoBRwYfQiGO2CiG0XB9ZBUg7HKc+MmFG9YADwTNz2ehlS9scwL8ibw10Q35M6YcMXD3zSWgtlhE2AsUQMExmUpzKPDvejJE1Bbi9MaWe0hQAz6O9Dh85DIIMMnTDCwnvshWU84NA75AZyED/EEFAoE3/sB0nfWdF/cOLLtSmhqhKEzcOWVJhDb/v3QcQ6n4wA4DvrkH0HrDoIXj6AFD3fTOpwE6PB59OwZst85jduWINYeA99He/IEhXa8t38Ed8c1U39uzeXwOzrou+u1eNu2UvM7HyC+a9fyn4wWyzzYnjsgIp8D3gB0q+o1RetfB3wKE/bqs6r6CeDNwIOq+pCIPAAsLO75HDLWC23rMD6zAAXY1kJs55uMZZvrAhl06x50LISeZ02y8Rehtwttb0DyWcSNrsejXRCLQfsOY2jhOJBIIY0tkB9CtWDs7VwPbdhKYu/VkGpA+g+iQc7Y/AV5NMiaaIujfabcIAuFcYilYPAU+IPgGi9XALIDkKw3oh4WkLCAJjIQSyNVbdMhfr0EJDLGPcozoXIlHgenGq3egEzGP9fQXGBGTkNNE7IzPmVKIuJEIY4L0LwFqWqEU/tMpMtkDdSZctxUNWgzjPdArg+NeTjrWqHjdDQfzIdDP4F0DbztffC9+yEIkb4iE5IwhP1Pws7zeDe+DoIC4kWnXV0D0tBIqr0GPduNUxgHYmiNh3SfR//3e/Hf/nd41+6mcOIFwmeegTDEDxT/6FFyjz5Kw2c+Q+quZfE2sFgWRaWI+0oHwr4PeF3xChFxgU8DrweuAt4uIlcBG4AzUbJyzhoz8TxobmWmY7hGXqFEwh7t14sh19xs8oBx//ELkJuYFZ89hMGOyBN00pxPoTACWpgZTdJzEfLIRDcEeZNuchuhMaCOFxtJqPEn9YdmerlObiuMGx9UJwZOHHE8JFlrYptHoj3pg0rDTiPsU22RnhZ2iMp3IV5v0kwJu0x9iwgEY+ZOJVkdhQyWueWkm823+nD08Kz2AiZG4fDTsOFKY1Q+GwV6hyD0p4WdyD4w04YkUsiGlqn2EEeQlhSSFPzPfxSAoY9/wsTrn9y3KjqRZfDDfzwjFr/FspJEXZoFP5cCKyruqvo4MPu//SbghKq+qKp54F+AXwDOYgR+8fXyYsbnczZuCfcjML3Iuqbp3wmvtM+VKoz0zMpbyooPQCE3SKnruSCmpz4jeUhZd62wyAvUjUW97zJBcp3YdCniUXIkUByITeeXkq5PkeNUphm8JFKqbqpmSChUaG0tUe8QTh2HWLJ0XQGGx2dcbIsyQ6LalJ2YacohVTGcoBeA3BNPlDzGoLeXsJxdocWyzCjmP32hz6XAaljYrGe6hw5G1NcDXwPeIiL/ADxULrOI/KaI7BeR/T0D46U9SjUs/dTDcSA7bTxNoKUfjogz1zu0nC8oYsbJS6CTdZmdvhzFPeZJt6Wy9oDFdS9zwVCFcBH9CMHcUWhQpj3ElCNAkXH3DDI18+8j5hmHqlKEBfMcJCiqq4D6ARqYC4JbX8ZKTwSnqqr0NotlBbDiXp6SpqGqOqaqv66qvz3fw1RVvVdVd6vq7ua0Q0kV97Nz1moYwFA/jA5NrxwrY+YsDtTPcrjwMnOSqUYCm26jZFM6rnmoOV2w6ZGHZULLeelovYI/YeqRHZhzgVANYKKoXA2NMM8pc/KuAhB3znadvIAgMHTeODjNbjlVCHIQ5s1wTS5Xot4eXHcLdL1Y/iLYkJqzTVUhDNDxQRjJQsGfXp8PYSKEa34egMxv/5Zpz2ISCdJvehOSnOeOwWJZZqy4l+cssLHo9wbg3AWVpKDPH4t8C40rueKg8Qb03Hm0UEDDwAj7SD/6xMOm9+44xqv06p1I+7ZoTDsa1/bisOPVU2JopFbQ0EG9mmgfmF5ofoL8iQHCME6Y3IiKi4pj6uAmwElEPV4XEDOLxolD41XTAj8puG4K3Lgp28+Z74l+NMihuUFUQ3MsGhrBHzgGQW6qLpobMDNjojSqITrRgwZZs4v+Dgh8c0zRx1xsquH57xt7QgdzYYzaTDVE/Ql05Iw5bi8F114BcWfavsr1YO/Pw7mj0N4Me/fO9U+tSyLX3QW+g2ZzU38X8hPouYNozyja2YkWQuN/OxGgJ0coxK8h/t4/BqDqnntw29vAcZDqakgkSN5xB3Uf//MLOnUslguhkoZlVmMq5D5gh4hsBTqAXwHuWUoBIvJG4I3bNzUTXvtq9OwJOHwMaWtH2lrh7DFGXughX4Ca7bV4KR+pTiNXXwcTOVSEoGccHW/ErW+EVIz8U0cIFeI7mnFPHoP6YWhqwclnwc8THPweVNcbb1Anhk6MI8EYTirGxP5+dKSAW694VR6SSkGsAJqj0D2EV9cAEz5u3kc8CCZGwGs2D229ABJ1UADUQ0WQWCLqrccg58PIOQhOmaGi6jYIXQgyuPk8eIrf14GMTqDZQfAwhtGZOnOhGu1D+7oIBwsQC3Gak0jCMybTWkALL4KThIFx3KEJQp2g8PC/4ngJdHAYpyUDyTROXRVkXyI81YF6ddCURobySGM9nHoa1rUgThr/bBfu5TvRvjFcOYy6MQqb34DbGcdp2orb3EAwNEJ44gBOfoAw3ADBZbivuRvteB7N56Dg4PzcLSSbWov/5nibNuGuW0fz3/4tbns7blvbsp2UFstimHygWgms9FTILwG3A00ichb4H6r6zyLyu8DDmKmQn1PVQ0spV1UfAh7avXv3+7zmt0EzxrNzkquhboEyZtzgbwfv5jIJU8aj1bvpY2XLil1Rfj/e1qIfmUfNurZ3L1C7RdAEVJlHE7GN73v55QG0HccBvDd+qnyaG+cvYsYJ9fe3m3W3/e7MNLXAphIFtV62YBXF84hff/2C6SyWlaJS5matqLiraknnZ1X9NvDtldy3xWKxrASXyrDLQqzGmPvLRkTeKCL3Dg0NLZzYYrFYlolKGnOvSHFX1YdU9Tdra2tXuyoWi+WnjEoR90smtozFYrFc6kz23CsBK+4Wi8WyBCpltkxFDsvYMXeLxbIa2DH3FcaOuVssltWiUsTdDstYLBbLIrFj7haLxbJGqRRxr8hhGTvmbrFYVgPFmE0s9LkUqEhxt2PuFotltaiUMfeKFHeLxWJZLZZL3EXkdSLyvIicEJEPLXc9rbhbLBbLIlmuqZDz2I0uG1bcLRaLZQksU8+9nN3oslGRs2Um47kD4yJypEyyWmD2E9cLXdeESO8FVncupd2KStVjseUtJe9CaWsRKbe9XN7529Ac79w2hQtr07KWh4uq12LLu/A2nVvefGXN36Yzy5qddultuvi2m4/Zf9sLy1uK6fIWPk8X06Yz67djcVUszzlyD3+UY00LpyQpIvuLft+rqvcW/S5lN1ou8PiFUezMU2mfqMEWve1C1wH7V/NYljPvQmmX2qZLaEPbpmugTS9Wu16sNl2tD/BfgM8W/X4X8LfLuY9KH5Ypa6RdZtvLWbfSvJx9LiXvQmmX2qbl1s9eZ9t0adsu1TZ9uftdbN6L1aarxfLZjZZBoquGZR5EZL+q7l7teqwlbJsuP7ZNKwcR8YBjwJ0Yu9F9wD26RFe6+ajIMfdV4N6Fk1iWiG3T5ce2aYWgqv7LtRtdCNtzt1gsljVIpY+5WywWi6UEVtwtFotlDWLF3WKxWNYgVtyXiIhUicjnReSfROQdq12ftYCIbBORfxaRB1e7LmsJEfnF6Dz9hoi8drXrY7m4WHEHRORzItItIgdnrS8V2OfNwIOq+j7gTRe9shXCUtpUzSvY71mdmlYWS2zXr0fn6a8Bb1uF6lpWESvuhvuA1xWvmCewzwamXxu+VEI3X4rcx+Lb1LJ47mPp7fqRaLvlpwgr7oCqPg70z1pdLrDPWYzAg22/siyxTS2LZCntKoZPAv9PVZ+62HW1rC5WnMpTKrDPeuBrwFtE5B+4tF5nrgRKtqmINIrIZ4DrReTDq1O1iqbcufp7wF3AW0Xk/atRMcvqYd9QLU+pcHeqqmPAr1/syqwRyrVpH2DF58Ip165/A/zNxa6M5dLA9tzLs+KBfX4KsW26Mth2tczBint59gE7RGSriMSBXwG+ucp1qnRsm64Mtl0tc7DiDojIl4AfAztF5KyIvEdVfWAysM8R4MvLHdhnLWPbdGWw7WpZLDZwmMVisaxBbM/dYrFY1iBW3C0Wi2UNYsXdYrFY1iBW3C0Wi2UNYsXdYrFY1iBW3C0Wi2UNYsXdYrFY1iBW3C0rhoiMrnYdLhQRuU9E3rra9bBYLhQr7haLxbIGseJuWXFEJCMij4jIUyLynIjMG8NdRN4pIv8pIgdE5B9FxBWRzSJyXESaRMQRkR+IyGtFZIuIHI2sD58VkQdFJD2rvCtF5D+Lfm8RkWej5Y+KyD4ROSgi94rInAiLInJKRJqi5d0i8li0XBU5I+0TkacXOi6L5WJixd1yMcgCv6SqNwB3AH9VSkTBCDHGEu5Vqnodxu3qHap6Gvgk8Bngg8BhVf33KNtO4F5VfQUwDHyguExVPQLERWRbtOptwJej5b9T1T2qeg2QAt6whOP678CjqronOq7/KSJVS8hvsawYVtwtFwMB/iLqLX8XYyTRWibtncCNwD4RORD93gagqp8FqjGx3/+wKM8ZVf1RtPxF4NUlyv0y8MvR8tuAB6LlO0TkSRF5DngNcPUSjuu1wIeiej4GJIFNS8hvsawY1qzDcjF4B9AM3KiqBRE5hRHCUgjweVWd48gUDbdMWhxmgJFoeXb0u1LR8B4AviIiX8MYWRwXkSTw98BuVT0jIn9apl4+0x2h4u0CvEVVny9zLBbLqmF77paLQS3QHQn7HcDmedI+grGFawEQkQYRmUz/SeB+4KPAPxXl2SQit0TLbwd+OLtQVX0BM8TzJ0z32ieFuldEMkC52TGnMHcTAG8pWv8w8HuTQ0wicv08x2WxXFSsuFsuBvcDu0VkP6YXf7RcQlU9DHwE+PdoGOc7QLuI7AX2AJ9U1fuBvIhM2h0eAd4dpW8A/qFM8Q8A7yQab1fVQcxF4jng6xjTi1L8GfApEfkB5gIxyceAGPCsiByMflsslwQ2nrulohGRLcC3ogeiFoslwvbcLRaLZQ1ie+6WVUFEGjHj67O5U1X7LnZ9LJa1hhV3i8ViWYPYYRmLxWJZg1hxt1gsljWIFXeLxWJZg1hxt1gsljWIFXeLxWJZg/x//kk+82Rw0foAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# here are trying to see the effect of using the chunk boundary as an expected instread of actual expected for a given pixel:\n",
    "\n",
    "# we can exaggerate the \"ledges\", i.e. make lambda-chunks very wide to see the side effect of replacing expected within each chunk\n",
    "\n",
    "for k in ktypes:\n",
    "    la_exp[\"la_exp.\"+k+\".value.chunked\"] = ledges[np.digitize(la_exp[\"la_exp.\"+k+\".value\"],ledges)]\n",
    "    \n",
    "# recalculate the p-values to take 4th item into account:\n",
    "for k in ktypes:\n",
    "    la_exp[\"la_exp.\"+k+\".pval\"] = 1.0 - \\\n",
    "            poisson.cdf(la_exp[\"count\"],\n",
    "                        la_exp[\"la_exp.\"+k+\".value.chunked\"])\n",
    "\n",
    "    \n",
    "# arbitrary p-value threshold\n",
    "p_th = 0.0001\n",
    "\n",
    "# let's test p-value for all of the 4 filters - feel free to play with individual filters/kernels as well:\n",
    "signif_pvals = np.ones_like(la_exp[\"la_exp.donut.pval\"].values,dtype=np.bool)\n",
    "for k in ktypes:\n",
    "    signif_pvals = signif_pvals & (la_exp[\"la_exp.\"+k+\".pval\"]<=p_th)\n",
    "\n",
    "\n",
    "# plotting - consider making it shorter:\n",
    "sct = plt.scatter(sub_la_exp[xlabel],\n",
    "                  sub_la_exp[ylabel],\n",
    "                  # color dots on the scatter by their genomic separation\n",
    "                  c=sub_la_exp['bin2_id']-sub_la_exp['bin1_id'],\n",
    "                  vmin=0,\n",
    "                  vmax = 100,\n",
    "                  cmap=\"YlOrRd_r\")\n",
    "\n",
    "# let's select pixels with \"small\" p-values:\n",
    "kinda_signif_pixels = la_exp[signif_pvals]\n",
    "\n",
    "plt.scatter(kinda_signif_pixels[xlabel],\n",
    "            kinda_signif_pixels[ylabel],\n",
    "            s=80,\n",
    "            facecolors='none',\n",
    "            edgecolors='b')\n",
    "\n",
    "# we can add a visual of the lambda-chunking grid on top of obs/exp scatter ...\n",
    "plt.vlines(ledges[1:-15],ymin=0.5,ymax=900,color='red')\n",
    "\n",
    "ax = plt.gca()\n",
    "fig = plt.gcf()\n",
    "\n",
    "ax.set_xscale('log')\n",
    "ax.set_yscale('log')\n",
    "\n",
    "ax.set_xlim(0.5,700)\n",
    "ax.set_ylim(0.5,1200)\n",
    "\n",
    "ax.set_ylabel(\"count\")\n",
    "ax.set_xlabel(\"la_exp value\")\n",
    "\n",
    "fig.colorbar(sct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Assigning pixels to $\\lambda$-chunks:**\n",
    "\n",
    " - After defining the bins for the expected (boundaries of $\\lambda$-chunks) let's actually chunk the data\n",
    " - this step involves *de novo* calculation of locally adjusted expected\n",
    " - l.a. expected is used to build histograms of observed data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Preparing to convolve 49 tiles:\n",
      "creating a Pool of 8 workers to tackle 49 tiles\n"
     ]
    }
   ],
   "source": [
    "gw_hist = dotfinder.scoring_and_histogramming_step(clr,\n",
    "                                        expected,\n",
    "                                        expected_name,\n",
    "                                        balancing_weight_name,\n",
    "                                        tiles,\n",
    "                                        kernels,\n",
    "                                        ledges,\n",
    "                                        max_nans_tolerated,\n",
    "                                        loci_separation_bins,\n",
    "                                        nproc,\n",
    "                                        verbose)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**determine thresholds using the fdr thing ...**\n",
    "\n",
    "[we should understand a little better - what is going on here with the multiple hypothesis testing, see https://github.com/mirnylab/cooltools/issues/82]\n",
    "\n",
    "long story short:\n",
    " - for each $\\lambda$-chunk we are calculating q-values in an efficient way, skipping calculations of p-values for each surveyed pixel\n",
    " - in part this is achieved by using upper boundary of each $\\lambda$-chunk as an expected for every pixel in this chunk\n",
    " - and in part the efficiency comes from collapsing identical observed values, i.e. histogramming\n",
    " - to be checked: q-values > 1.0 seem to be weird - we need to check if that is ok\n",
    " - also to be comared with the stats-packages implementations - just in case, e.g. `from statsmodels.stats import multitest; multitest.multipletests(pvals,alpha=0.99,method=\"fdr_bh\")`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this determines observed thresholds for each chunk and corresponding q-values for every observed value\n",
    "threshold_df, qvalues = dotfinder.determine_thresholds(\n",
    "    kernels, ledges, gw_hist, 0.99)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**overview of the 2D histogram**\n",
    "\n",
    "x-bins corresponding to the $\\lambda$-chunks and y-bins correspodning to the observed counts ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/venevs/miniconda3/envs/dots-stable/lib/python3.6/site-packages/ipykernel_launcher.py:3: RuntimeWarning: divide by zero encountered in log\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'lambda-chunks')"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmcAAALkCAYAAABKlpJnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3XecVNX9//HXmdnO0nsvIiIIAq6o2MAKsUcNaoyJBcvXEhuWRP3ZYyAqJppYorGRGE1iNKIo9l4AsaCgBAFRQhOWsnVm7u+PS9kyMztzmLn37uz7+XjMQ3bmnjmfoI/HvnOqcRwHEREREQmGkN8FiIiIiMh2CmciIiIiAaJwJiIiIhIgCmciIiIiAaJwJiIiIhIgCmciIiIiARKocGaMGW+MWWiMWWSMucrvekRERES8ZoJyzpkxJgx8BRwKLAc+Ak52HOcLXwsTERER8VCQRs5GA4scx1nsOE4N8ARwjM81iYiIiHgqz+8C6ugJfFvn5+XAXg0fMsacDZwNUFAc3qPLgJK0O4o6dpk030St2tU6Yat266rT/98GYDbY9Ze3erNVu0F7DLBqJyIi0pLMmTNnjeM4nZt6LkjhzMR5r9Gcq+M49wP3A7TaubvTZcoZaXc0tsfXabcB+Gn7963a9cqLWLX7oLqjVbtrv7AbcMx/qoNVu48eudSqnYiISEtijFmaynNBCmfLgd51fu4FfJ+sQaQmzJrl7dLu6OvWXdJuA7C+bbFVu11D1VbtBuevsWo3pNNKq3afdrYLgyIiIpI5QQpnHwE7G2P6A98BJwGnJGuQv8HQ68V4A27JfVrbz6Y+Xmgz3KrdLvlvW7Xrl2c3rXl0p4+t2r0zeGerduOHXWPVbuZnN1u1ExERyWWBCWeO40SMMRcALwJh4CHHceYnazN4p66888/LG38waxasWQMnn+z+vHAhRCIwdCgAu18xldpwGEx6wW5+efe0nt9qdXu7v+bueXZr43rmrbNqV9yh0qpdZa/WVu1ERESkscCEMwDHcZ4Hnk/1+a8/Wcb47ucDcOrGDzl18+z6D5xyCo+3KqN/ZC09ouWc1+kkAO4JvUbHqo38YsLFAFz9/lPkOVFu2uekpP19s9ZuTdbinp2s2g3N32DVrkOoyqpdlzabrNrVtC21ando6ESrdrNiT1m1ExERaQ4CFc7S5UQiRFeuAuAR+vGI6QdAkROhiAjrTRFUwE5OW0rY/uybfXelKK+Wtl9u5Gffv86x//sAgCMXbw93j3U7kMd6jK3XX/nHba3q/E/PEVbtRhXOtGrXOZz+VC/A8A7fWbV7dUAPq3bvKWSJiIg00qzD2aA9BjBrdvq/4N0Rm0L4dj6P0plHzQnkOTGKqWUTBTjGwEpgZf1Z1TZD9raq878b7EbOVnctsGo3wHJ3aJeCjVbtakuDcZCxiIhILmjW4cxW3Gmx+++Hc86B5cuhZ8+47WwXvi/Yp6tVu/d77WTVrkfpl1bt+heutmpX08Hu/LcJAydbtXth0VSrdiIiIs1BiwxncY0ZA3fdBW3aJHwkOn+h1VcXrhlj1e676vZW7apaWTWjdchuQ4AptRupi3TSRgIREZGGFM622m0395WE7UL0/X5sN9Lz7hi7k/ePbmt3lEa7cIVVu7Zt7drFiu3OjRMREcllCmdbVVfDDz9Ax45QYLfWK5GSpXbXIn270W4IbG3Mrl27kF3IKimssWpX1cFug4WIiEguUzjb6oUX4LjjYO5cGDkyo18dLrcLZxXr7TYSrI/ahbOOIbs6S/Ptwll5id2uUhERkVymcLbViBHwpz9Br14Z/2rbBeyDbrrTqt2XlXZHW/TLt9sQ0LnY7ny0Ve3sDtkVERHJZQpnW/XrB+ee63cV9RTZXa3J6hq7Q2FrHbv/HFrl2d0dGtN/fSIiIo3o1+NW1dXwv/9B585QYnenZaa1WhmL+37rmgo25RfhmPgjTwvX2x3dsbmD3Vq7dvl2uzyrOtmdj2Zzs4BuFRARkeZC4WyrOXNg333hxRfhsMP8rgaA0iXb14D9bPlrnPbd642eebTnWB7veWC9oLa6qtCqv6qYXTgrCtVatXPCVs0UtEREJKcpnG01cCA89BAMGeJ3JdvMev+6Oj/V+fO//w2rVsHZZ3MacNqYMW6wnOqubev78G+t+lsdsTt3rCRktyEgWmQ3crb1PtV0zFxxj1VfIiIiXlM426pLFzj9dL+rqCfeCfr9qldT5NSyoKgHTJlMyIlxxtoali76jFlPTybsRPmH8zR/HncgL+0+LK3+KmJ2I275xu6GAKfQLpxtvSNVREQkFymcbVVTA0uXuiGtbTDO34q7y/PEE2H+fPhieqOPLgX47js+OOBZnGiYcJWha3k5F7/0AvePPYhvOndJ2t/GaJFVnW3z7M5Hc8K6k1NERKQhhbOtli2DQYPgscfg1FP9riaxm26CTUmOrujZk9MnutN+Beth8DerOOzzz3l05DgK8g2tqyqpysunNq/xv/qVNYmvrkqmQ57d+WihUru1ambkUKt2IiIizYHC2VbdurnBbIzdPZjZYLMrESDvwu3/G8oWL6ZtVSX/eWBKvWfu2/NQ7tlnQr33NtTajZzZCoU0ciYiItKQwtlWpaWBGzGLuyvxvffAGNh774Ttys64Y9ufHxx6OA8OPXzbz3t9t5B+5av4+5D9Kdjo0Ld8FUvbutOdKyvtNgTUtrHbdllQaDdyVtPR2xApIiLiJYWzraJR+PJL6NrVPessAOKNnN3uvI4DXG7GJmxXdOzohJ990mogn7QaSNH6KAPXf89Dr93Fb0adyAt9y9hYbbchIIrdNUzhcPxz3JpSsLbKqp2IiEhzoHC21ebNMGwY/O53cNllflcDJBg5W7AAYjFmJTny44AjpiT8rK7lBZ24d/AE3uk4hFC1Q5uvK6goKmBN+/RG0Gotj/ovyo9YtXPyNXImIiK5S+Fsq5ISePJJ2H13vytJbvDgJh8p2JD6dOG/Oo2BSiiorOX/PTCDvit/4OA7LyEWSv3ey5jtyFnIbuSsWtOaIiKSwxTOtsrLc4+pCLpZs9yjPkYnnroMVdit5brmlOPou3otNTUF4DgcPnc+L4/YlWg4+Zqyqli+VX+FYbvz0aJFujBdRERyl8JZXR9/7K4369XL70oSu+gid/r1yScTPuLk24WXpa27srR1V8xm2GfhIu6/+3EuOe0knh69R9J2lVG7cJZvGc6qWqU/Ume781VXRYmIiNcUzuraZx/45S/ht3bXH3ni3/+GguR3YOat2Wj11aGq0m1/3nvBYgDufPQJ7nz0iW3v33XoYdx1+OH12tVaXpKZH7K8WSCUfjhTyBIRkeZC4ayuf/wDdtrJ7yqS22WXJh9xNtud2B+u3v7nu8eO5+6x4wHosqGcvz1wD3ePO5SnR+1Z7zmAjRG7NWB5lmvOakrt1riJiIg0BwpndR15pN8VNO1f/4K+fWGPxFONsR52R4GEK+OHnk2U8Fm3Pvy3Xfe4z9TG7EbOQtgdQhuu1eG1IiKSuxTO6po7F9q0gYED/a4ksUmT4JRTkoazl+Zcb/XVwy69M+77MQq46vCfAZC/GXZduZwvu/R0D8MFNtXanY+WZzmtWVuikTMREcldCmd1HXssHHIIPPSQ35Uk9t570Dr5OWS2i9+5pOmrq0Z89w2P/P1urjt8Is8MdXeM1liOnBWELc8503+1IiKSw/Rrrq7HHoOOHf2uIrlBg7L21eHKpqcLP2/fhyn7HcOsPiO2PV8ZsdutWZpf3fRDcUST74cQERFp1hTO6jrwQL8rSM5x4JFHYNQoGD484WO2OxP3/MUdTT9EiH/utD/UQKvKWn7y5dv8/chdiYa9O3vMcnOoiIhIs6DTPOuaMwc+/dTvKhKLRuH00+GZZ7Ly9U4ovdf+y+dz4ZwZ7DbvO2oi4bRfMcdYvTCk/xIREWkmNHJW19lnQ/fu8NxzflcSXzgMixe7NwQkMb77+VZfXzimf1rPv9VhOD8/+BI+GtwG7GYorUSKtVtTRERyl8JZXffdB0UBvrfRGOjfdICKrlxl9fWRogFpt/mqqAfRaAVDFn/Phf94nckX/JhNJdn9OzTKZiIiksMUzuoqK/O7guQqK91NC/vvD7vumvAx2zVnBxwxxapdbVUePZaXs9O3qylcH2VdKLX/rGKO3Xyj5eZQERGRZkHhrK65c6GmBvbe2+9K4lu3Ds45B+69N2k4sz1KI3RI8js0E3GiIZ7fY3deHj6Umvw8iDiUVlWzqTj5CFrMsVvyqA0BIiKSyxTO6vr1r2HtWvjwQ78ria9rV/juO/eg3CRsR84OHnerVTuq3aM0aiiAarjg+Vc4/v05/PiK81lX2iphs5jtSv2Q5jVFRCR3KZzVdfvt7o7IoAqHoUePrH19qNLuUFhTW//gsfd2Gkin8s2U55dgahMHMOtpTf1XKyIiOUy/5uoaMsTvCpJbuxb+9jeYMCFYF7TXCVkXP/8iF8+cBcDpb7y97f1p4w9l2o8Or9fMNpyRl/7I2fhh11h1NfOzm63aiYiI2FI4q2vePFi9Gg491O9K4vv2W7jwQnj66ayEMyffbjFXXsX2kHX32PHcPXY8AH3XrOb3f32MX//4RD7v1Zu8ivrtbC9Md8LphzOFLBERaS4Uzuq680544w1YssTvSuLbbTdYtarJuzVtOXl2I1kmwUzwuqJSIqEwpZXVcZ+xHjmzOEvDdpOE7fo9ERERWwpndV1/PWze7HcVieXlQefOWfv6/DUVTT8UjxN/V+bGomJOOOci93y2OHkqGrO8oEL3WoiISA5TOKsrhQNefbV0KfzznzBxIvTsmfnvX7POqlmoNtll8QYch5PmvMf87r34rGefbZ9EbMOZhXDXLp71JSIisiMUzur69FP473/huOP8riS+hQvhssvcc9iyEM5mrrjHqt2Qq+9M+nmr6mrOe3MWrw0cyhedtoezqIfTmqZViV1fIiIiHlM4q+uxx+Cee6DCcnov2w4+GMrLoSQ7QWPCwMlW7ZyJyY/32FRcxCmnXcSKNu3qXULuWIez9Ju8sGiqXV8iIiIeUzir69JL4fTT/a4isXC4yQNod4RTXGjVLpTC0XArS9sTikGbqgraV2xiaYcu1EZt15ylP3JmGzwV6kRExGsKZ3V17+6+gmr+fPjPf2DSJOiYbJ2XJcs1Z/kbO6T2oONw/z/vpyAaYeJPLiVmuebMWIycRRYvsepLRETEawpndX3xhXu/5sknu6NUQfPxx3D11XDCCVkJZ9GVq6zaOaGBKT5puHPfI6nIL8QJh6yP0jDhWNpt8gb0s+pLRETEawpndc2YAVdc4W4IaJX4TkjfnHKKG8wKCpp+1oLtmV4jz70j5Wc/7uIenhuqdYhVO0Ty0g/BNmvVbKdsRUREvKZwVteZZ8Kxx0Jxsd+VxBcKQVH8M8X85FjMTp76yRscMfNDTvjNJGrzs/+foamsznofIiIimaBwVleHDu4rqN5/H1580R3dy0KAHN/9fKt2+Yelf5XUt8Vd+KJvd8JVUGXSGz0zFhsCtOZMRESaC4Wzur7+Gt580z3ktbTU72oae/dd9xaDSy7JSjizPees7PTUpzW3eqf3rjx3eD+r/uLdNtCk0cPs+hIREfGYwlld774LZ50F48YFM5xdeilcfLHddsUU2I6cMd7uEnbHMfRYvY7/e/YNbjztSGpSnN40FtOo4c016TcSERHxgcJZXT/+sRvMeiQ/VNVXoexdeWQ7crbPxN9ZtYvVhhi4dA1HvfMpf993Tz7ZqXdK7UL56e/WrO2kGwJERKR5UDirq3Vr9xVUL74I77wDN97odyX1xPLtRvKcqOG13Qaz75QrKS8tgRQOswVwLP6rjYV1W7qIiDQPCmd1LVsGzz/vjqB1CeBF2W+9BdOmBS6cFZanmKoairqhrry4FURhvy++4sOdBzQ5vWkzq1u4cpNNhSIiIp5TOKtr/nw47zwYMSKY4ezmm91XlhwaOtGu4YQ97drFtqeswctXMP3OB7nphCP586EHJG3mWGwIiLQL6PEoIiIiDSic1TVuHKxYkZ2rkZoB20NoDzhiilU7E9kezhZ268E5k07jtaG71ns/U5y87GyiEBERyTSFs7qKiqBbN7+rSOzvf4evvoJrr/W7knpCtekv0AfqnV578YyXuPiFWY0emTbhUKYdcViDdul3Fc3XmjMREWkeFM7qWrkSnngCjj4a+vf3u5rG3ngDXnkla+HMelrzkD3s2tUJWdN+dBjTfnQYuy1bzm+e+AcX/uKnLOnSudFzYHd9U9g2QIqIiHhM4ayu5cvdc8QGDAhmOPvjH7P69eGuduvsIpa5x0Qbh6xVpW2JYeiwoYKlHROEMJsbAooCeJG9iIhIHApnde2+O6xdG+zjNLLI9pyzA46yW3MWqmkcvtYWt+XHF16y5fP47aJxQl1TTNTmWgERERHvKZzVlZcX7Ls1770XNmxw79bMAtsbAgr7drVq54QS38KQH4nQtrKSNRkKytXt9Z+6iIg0D/qNVVd5Odx/P4wfD8MCeBfjm2/C//6XtXBmO3J28LhbrdqZRMejOQ7PTJvGkk6dOP9nv7D67oZCkYx8jYiISNYpnNVVXu4Gnw4dghnO/vpXvyuIK39NhVW7cHWis8cMD40Zy9pWpYSrG09hRmIW05o2h6OJiIj4QOGsrl69YONG90gNSVl118xfEv/vEZYH2yYQtbxiSkRExGsKZ3WFQlCa+aCRMbfe6tZ30UV+V1JPuNry+iaTfDSr/eZNHLxgPv8YNbr+nU0WI2eRIp1zJiIizYPCWV01NTB1qntTwJgxflfT2DvvQLt2Wft663PO9h1h166J88oO/eJzbn72KT7v0ZsF3XrWaZd+V5rWFBGR5kLhrK5YDK65xh2hCmI4mzEjq19ve33ThIGTrdqFakuSfv78rqP4pHs/vu7YnVCtVRfbhKvtwpltYLX9uxQREVE4q6uw0B09y9NfSzqibVtZtUu4W3OLynAhizp2b/xcJP0pypjlmjOFLBER8ZpSSF3GQH6+31UkdvnlsMsuMGmS35XUEy7fbNXOOG2bfKaotoZLXp/B3F79eXFXy+lTIKaLz0VEpJlQOGvo5pthjz1gwgS/K2ns/fchh9ZOJboBoK4aJ5+9lixiXWEpoZ12oK9I7vy9iYhIblM4a2jqVDjrrGCGs7ff9ruCuJzNduecOSn912c44fRLiYZ27G7MSKFGzkREpHlQOGto/fr6xzZIk2xvFhj+yztTfDJMGCiI1FKTZzftnFoQbEwbAkRExGsKZw0FOZj94hdw6KHw05/6XUk9tndyOicPTPnZsz58mRM/fY8fnfErq6M0wtXptxEREfGDwllDv/0t9O0LJ53kdyWNzZsHQ4b4XUVjndpbNUvneIwFHXoxc+eRFFfWsj6W/uhZzHJWVCNgIiLiNYWzhh59FPbeO7jhLIjWrLNqFqrtkPKz7/fYhfd77AKAE7K8kUBERKQZUDhraP58vytodkyr5IfJJhItSnMK2XEYsmo5C8rbsr40vbPVooXpdSUiIuIXhbPmorraHc37+c/h2GP9rqYep9gu+RSuT2/xWO8Nq3ni6Tu5ufpI/nzIgWm1DadwbIeIiEgQKJw1NG0aFBXBuef6XUl9kQgsXuzuJg2YmZ/dbNVuxP/dkdbzi0s6M/mw03hx9M6Y2vRG3WLarSkiIs2EwllDzz0HbdoEL5y1agWffOJ3FXFZX5h+3j5pN5k1cHc2lqS/XVPXN4mISHOhcNbQyy/7XUGzY0YOtWoXrrLr75BP59Nj3Toe3X+/lNuEanVDgIiINA8KZ83FypVw+ulw2WVw8MF+V1OP87HdJgqze/ojZwDjP/mMYcu/Zfpe++KEUrsE3Un/rnQRERFfKJw1dO+98MMP8Ktf+V1JfbW1sHo1VFkONwWQ7X2XNx95LJsLC8EJYVI8VcMJ2U1ras2ZiIh4TeGsoXffhe++C14469ULPvooq114HURGTUpvQ8BW5W2L3D84sZRvdLC9IUAhS0REvKZw1tCjj/pdgW9sg4jt9U3mRzvZtas1DP92GVOefIJzf346Szp1brJNpMRu5Mz2f5vtfaMiIiIKZ83FggVw4YVwyy0werTf1dRjG0T2OvV2uw5DhhXt27GuVStaV1dCCuvJjOV+AIUsERHxmsJZQ488Ap99Br/7nd+V1BeJQEUFOLmz6zC/ImbX0AmzunUbTj5vy6hWCn8lxnJ9m9aciYiI1xTOGpo/H954w+8qGtttN3jnHb+riMs2wMSO38uqXd0L0wtra2lbWcGqNm2tvqspClkiIuI1hbOGpkzxu4JmxzbA2E5rmq0Dbo7Ds3ffztddunHhyb+w+i4REZGgUThrLt59F666Ch54AHbZxe9qMqJobcSqnYkWbP0Tdx94OKtL22CiyRf8O2GrrkRERDyncNbQk0/C88/Dww/7XUl9jgN5eZDioatesp3WrDnRblqTOjlsxvBRKTUJ1+TOWj0REcltCmcNLVsG77/vdxWN7bsvvPqq31XEZTutOeZEu00XToNBsi4byjlkwef8dc8xCc89i2nkTEREmgmFs4Yuv9x9Sdblb0rxeP8GGl7ZdODXX3D9c//kw/79+bpr97ht6m4iEBERCTKFs+bi2Wfh1lvhmWega1e/q6nHerfmUXbntYWr64+OvTB4FB/1Gsiydp0T3gTghDWtKSIizYPCWUMzZsBf/uLeFFBS4nc12+XnQ9u27rqzgLGd1jx43K1W7ZzQ9r+DC16fyYVvvNTomT8ceBh3jx2/7edood0NASIiIl4L3m96v61dC19+6V40HiQTJrivALIdOaudsKdVu7qn/d9z4HjuOXA8g1Z+z0lz3uWOg45gU1Fxo+dCtRo5ExGR5kHhrKHTTnNfknX5FbZHaeQ3eq/Txk0c/ekc/jVsL+b36N3ocyekkTMREWkeFM6aiwcfhHvucXeSFhQ0/byHbKc1xx1ym1U7J85pIu/3H8joybcQS3DUiMmha69ERCS3Be/QLL+98QYcfTR8/73fldTXpg306gXh3DkTIpZvrF6hCI1exEIQC8X9LBSBWJ6xeomIiHhNI2cNVVTA8uVQU+N3JfWdeKL7yiGZXgd28FefcdynH3LB8Wc0Ou8sXK2Lz0VEpHlQOGsowAvvc00oGmv6oThMgmatK6votmE97TdvZn1Jab3P4k2FpkIhS0REvKZw1lz85jfw73/DBx/4XUnGxMJ2ickkOLv22SF78uyQPZM+IyIiEnRac9bQ3Lkwfjx88YXfldTXrRsMHux3FRkVisasXlaM5UtERMRjGjlrKBKBdeuCt+bs9NPdVw6xHTlL5uz3ZzHiuyX83/GT6r0fsju1Q0RExHMKZw2NHp1TU4dBZrsOLJQkN1eECikvKCFU7dTbFNDwsnQREZGgUjhrLi65BD77DF5+2e9KMub1l66yajfs0jsTfjZ9jwPivm8bBEVERLymcNbQ11/D2WfDTTfBfvv5Xc12AwcG9owz2+MmnH1HWLUzezR956lxYjhmeyILWW4Q0FEaIiLiNYWzhoyBaBRilgvPs+X88/2uICHPLz5vIqPe9cxDRI3h0qO3r9GzndZUyBIREa8pnDU0cCC8+abfVbQI+Wsq7NptKkr6+bzO/XEw5G/afvCsjtYQEZHmQuGsuTj5ZKiuhn/9y+9KMsZUVlu1ixYkHwZ7pGxco/fCVbpbU0REmgeFs4ZWr4bjjoPJk+GYY/yuZrs99oDaWr+ryCinuNCqnYk2HbTCsShFkVo2F2wZZdOGABERaSYUzhoKh6GwMHiL7y+/3O8KErJdNM/oYVbNEl3ftO1zJ8aLj93ESzuNYOq+xwJQ20pnaYiISPOgcNZQhw7wyit+V9Gs2C6aHz/sGqt2TR2L4RDioVEH8U37rtuezd+saU0REWkeFM6ai7FjoX9/+Mtf/K6kEduRMzNyqFW7go1NB61/9N+/3rOREo2ciYhI86Bw1lAkAvvsA+eeC2ee6Xc12x1yCHTu7HcVcVmPnHW3Ox6kds82TT/kOHTdvJ7qcD7ri0ubnAoVEREJCoWzhsJhNwSVNH3QqaeusZsCDDLTyu7vuKlzzgA6VGxi5vSb+d2Yo3l8xIE6SkNERJoNhbOGjIHnn/e7ihbB2Wx3zlmyuzW3Wp/Xmhv2/wlzuw1I6XkREZGgUDhrLnbeGY48Eu5MfK9kc2M7cpaX4pllM/qO3vZ8tFBrzkREpHlQOItnv/3cIHSV3cXcWXHSSTDM7uiJoHph0VSrdnudentKzxVGahi2Zilfte9JuQnYNLWIiEgCCmfxDBgAnTr5XUV9N93kdwUZZ7vLM3LGPik9t8vqldzzyn1MPujnvNpvuFVfIiIiXlM4i+fRR/2uoEUId+1i1S7Vac3/lnTnooMm8Xmnvlb9iIiI+EHhrLkoKYGrr4Zrr/W7koyJrlxl1S6Wt1NKz9Xk5fNe78HuD1pyJiIizYRuHIxnwgS49FK/q9jOceCii2CvvfyuJBBCESflV/fyHzjxi7fJr4lgoqT9EhER8ZpGzuLZdVfo18/vKrYzBm67ze8qMi48dBerdrXFqQ+DDV7xLVd89DSfd+rLgo69rPoTERHxksJZPHfc4XcF9Tlb1liZ3Jqbi85faNUuf/e9U372o06DOPaYX/F96/aa2hQRkWZB05rNwdq1EArBPff4XUkgOKHUX5sLi/i+TQdi+SFieSbtl4iIiNc0chbPT34CeXnw17/6XYmrqMjdCFBW5nclmTXa7tw2J5ReaBq+6hvGLF3Ig0MPs+pPRETESwpn8ey+u3vHZlCUlsKNN/pdRcaFN9vdq5RXmd4t5iO++4ZTvnqDx4YfyOaC4rTa2p7FZnsZvIiIiMJZPL/+td8V1BeLQTTqjubl0LozU1lt1S5akN7fwZND9uWvww4gGgpjnNTOSNvKNmQp1ImIiC2Fs+ZgwQIYOhSeeAImTvS7moyJLF5i1S5/965pPR8jn1iRsToaQyFLRES8pnAWz6RJsGgRvPaa35W4OnWCm2+G4bqCCCBck960JsBRX39E781ruG/whLTaKWSJiIjXFM7iGTUKevb0u4rtunQJ3lRrBtiec1ZTmv56wH61Kxn9YpJ3AAAgAElEQVSycRmVHcM5NTUsIiK5J2vhzBjTG3gU6AbEgPsdx7nLGNMB+DvQD1gC/MRxnHXGGAPcBfwIqAB+4TjO3GzVl9R55/nSbUKRCFRXQ3Gxe6RGjpj52c1W7UafdnvabX6/21FgDPlVDpDeujMREREvZXPkLAJc5jjOXGNMa2COMWYW8AvgFcdxbjPGXAVcBVwJTAB23vLaC/jTln/K22/DuHHuNOvYsX5XkzETBk62alcw3O7CdIUyERFpDrIWzhzHWQGs2PLnjcaYL4GewDHA2C2PPQK8jhvOjgEedRzHAd43xrQzxnTf8j3euvxyeO45dyF+EPTvD1OmwE6pXfjdXDjFhXbtLKYlnTBc8vG/qcgr5L5h6a07ExER8ZIna86MMf2AkcAHQNetgctxnBXGmK3DID2Bb+s0W77lvXrhzBhzNnA2QJ8+fbJT8J57Qn5+dr7bRt++MNlulCnQ1qyzahbu0ybtNtXtwxQ4tdQSTvsoDhERES9lPZwZY0qBfwIXO46zwSQe9Yj3QaN5KMdx7gfuBygrK8vOPNXEicE6sqK6GioqoE2bYB2Ou4NMqxLP+grVOty2x4nb/iwiIhJUWV1dbozJxw1m0x3H+deWt1caY7pv+bw7sGrL+8uB3nWa9wK+z2Z9zcYzz0CHDrDQ7qLwnBNK/2Vzr6bu1hQRET9kc7emAR4EvnQc5446Hz0L/By4bcs/n6nz/gXGmCdwNwKU+7LeDNwzxX77W9i40ZfuGxkxAqZNg+7d/a4ko5zNFVbtogXp/38KE4NwLMp9r9zD2z2G8PDQQ1Jqp0NoRUTEa9mc1twX+BnwmTFm3pb3foUbyp40xpwJLAO2/vZ7HvcYjUW4R2mcnsXakisrg3POAccJxplYgwa5LwFI+womgHANQIhvSruxtqAN4RpNbYqISDAZx+IXXVCUlZU5s2fP9ruM7Nu0CTZvhs6dc+qcM9tRqZrDy9JuU2txcC3Au09dbtVORESkIWPMHMdxmvwlphsCmoO//AUuughWr3avcmrhatqm/59trE4T48QIx2JEwk1/j6Y1RUTEawpn8fzpT24YWrEiGGFo7Fj44x+hdWu/K8ko2wBzwFFT0m6zdZ1al4r1PPby7dw1/Gie77dnk+0UskRExGsKZ/GMGAFXXAFFRX5X4ho2zH2JK/17z4kUuWsHVxS2ZcaAMr7p2GXbeyIiIkGicBbPPvu4r6BYt87dOdq7dzA2KGSI7ZRh6JA90m8T2bpWzzBtxDFb3mu+6y1FRCR3KZwlEou5QSgIYeiOO+CWW9yacki4q90dmRGLv4Zwg4NnO1RtZGN+MbUprDsTERHxkn4zxfPkk+4NAfPnw5AhflcDxx0HAwb4XUXGzVxxj1W7cYfclnaburcCjFqziGnvP8DFe09ibqeBSdtpQ4CIiHhN4SyeoUPh+uuhY0e/K3GNGuW+csz4YddYtYsMaJt2m7qn/X/ZqTe/H3YUy9p1tjrQVkREJJsUzuIZOtR9BcX//geVldC/v9+VZFR0vt11VMUF6f+72TiwdNufN+QV87ddD0ipnUbARETEawpn8cRiUFMD+fnBuGj8//0/ePZZ92iPHGK75iyab3d9U12FkRoGr1vOJ536B2NdoYiIyBYKZ/G88QYcdBC8/joceKDf1cAZZ8Bhh/ldRcbZrjk7dO8b026TV1U/nf1o6Rwmf/YvThp3Bd+3Csj0tYiICApn8e20E9x6K/Tr53clrr32cl8CQKzY4oaA/PqjY+/03JVVpaezprRNvfVoIiIiflM4i6dPH7j6ar+r2G7pUohE3NAo5K+pSLtNbUmbej//EGrDB+3bQBRCUZ13JiIiwaFwFk8s5l40XlgIBQV+VwMXXwyLF8Mnn/hdSUZNGDjZrmFxYdpNwtWND0frUbGWgZtW8GaX3ezqEBERyQKFs3i++MK9LunJJ+FEu3OuMmryZNi0ye8qMi6yeIldw9HpX2UVLW68ieDwpXM45b9vMGH8DVSHAxDCRUREUDiLr3t3+N3vYPhwvytxjRnjdwVZYXtMxcHjbk27TbzzzJ4eOIYZA/akoqhQOzZFRCQwFM7i6dgRLrvM7yq2W7AA8vJgYPLT7FsKY3EnZkF5pNF763HPPivYEN3hmkRERDJF4SyeWAx++AFKStyX3844A1q1glmz/K4ko2yvRmLfEWk3CUXrrzk77ZtX+PnSVxs990jfg3i0/8F2dYmIiGSAwlk8a9ZA165w991w/vl+VwNTpkBI1wxtFaqoTbtNTceiej//ZdCh/GXQodwx+wEKYhEuGH1epsoTERHZIQpn8bRpA7//Pey/v9+VuPbbz+8KssJ2zZntnZzx3DTsJDbnFTX9oIiIiEcUzuIpKoILL/S7iu3mzoXWrWHnnf2uJBBMZXXabaLF8S9LX1PcbkfLERERySiFs3gcx73HslUraBv/l7qnfvIT94aA6dP9riSjxne3mzKuHdwz7TZ5m+Mv+u9auY5D//cxM7vvwZqiAPy7FhGRFk/hLJGePeG66+CGG/yuBB5+2B05yzG2d2vaHKWRSMeaDZy5eBYL2vSKG85sNy3YTtmKiIgonMVjDNx/P4wa5Xclrhxdc2YbfEIWh9Ca/HDc9xcVdOeIfa6jOlxAuFpHaoiIiP8UzhKZNMnvCrZ76y3o0UN3a26Rt2Zj2m0279I5wSf5Sdulf1GUiIjIjlE4S2TZMiguhs6Jfql76Igj4Kyz4I47/K4ko8Jdu3jWV6i28d2aW/3ou4/Ij0V4pvc+jT7T9KSIiHhN4SyRsjI44QT44x/9rgSef949dy3H2K45s7kwPZwknO2/cj5F0Vqe67ZXo8+05kxERLymcJbIH/4Affv6XYUrR9ec2Yp0Sn9zRKiy8fVNW12/00RiJhz3GYUsERHxmsJZIhMn+l2BKxaDl16CXXaB/v39riajbEel8gb0S7tNbffE55lFib9ZADRyJiIi3lM4S+Sbb9zLxnv39reOmhqYMAF+8xu46ip/a8kw2wBzyP63pN0mWpg4gPWsWMPEpW/xZN/9WF5Sf43hawpZIiLiMYWzRI46CgYPhn/8w9868vPh3Xf9D4kBkrfo+7Tb1I7ok/CzAlPL/qvn81qPYSzL926TgoiISDwKZ4lMneresem3cBj2abyLMBd4Oa1Z8vWahJ+toICT+5wH66BkXeLnREREvKBwlsiECX5X4KqsdNecjRwJfRKP/jRH1hefW1z7FO2be7tdRUQkNymcJbJ4MUSj/l82vno1HHssPPggnHGGv7VkmJcjZ5HSgqSfn7T0DUoi1Ty002FWNYmIiGSKwlkiZ50FtbXu6fx+6toV5szJuVEz8HbkLBRtn/TzXpvX0Lq2klA08XloIiIiXlA4S+SGG8Bx/K4CCguDc8dnUHRKHrTiiRQl3q0JMGX3E+K+r6M0RETEawpniey/v98VuNatg1degTFj3Ps1BVNZnXabghcXZqESERGRzFM4S2TxYti0CYYP97eORYvgxBPhP//JuXBmOyrl7Dsi7Tb59Ev6ea+atZy99nUea78vXxd12/Z+ZPGStPsSERHZEQpnifzqVzBvHixY4G8du+0Gn32Wk2vObNmccxZpYrdmdVUt7dZWUdA6j0jb7ddDzVqk6UkREfGWwlkiV1wBGzf6XQUUF7sBLQfZrss6bI/r02/04WdJP14B/B/7wsJNQPJnRUREsknhLJGgLML//nt47TU4/HDo1MnvagIh9P3qtNvERg616ksbAkRExGsKZ4ksXgwrV/p/Ov/HH8Opp8KHH+ZcOLM5EsNWKoHu9I3v0SFawe3tDt723kyFLBER8ZjCWSJ33gnTp8MPP/hbx9ixsHBhTt6tOXPFPVbtxg+7Ju020VbJD6EFqFnehpqakG4TEBERXymcJXL++XBC/LOvPNWqFQwa5HcVgZJK0LLxaK+DsvK9IiIi6VA4S2TwYPflt6+/hnfegeOPh9atm36+BQgvXZl+I4uDa0VERPygcJbIkiXuGWMHHwzG+FfHW2/BmWfCuHE5F85sF9uHh+6SfqM165p8pE/kB65e/xL3tt6PTwp7WVQmIiKy4xTOEnnsMbjuOvd+zTwf/5omToSDDoKePf2rIUtsdzROGDg57TbRHp2bfKa8tpgVtZ2p7tyRWKn7vHZrioiI14wThPsjLZWVlTmzZ8/OzpcvXQrffutemxQKZacP8YzNJgKAmZ/dnOFKRESkpTLGzHEcp6yp5zRylkjfvu7Lb/PmwQcfwBlnQH6+39UEgs0RHNqBKSIizYWGhBJZtgxmzIDq9C/ZzqiZM+HccyES8beOZi5WnJfS64JvZzB14cPbfhYREfGafvsk8sILbij67jt/Lxy/8EL4+c+hqMi/GnJA/pqKlJ5b5nSgIj8v5edFREQyTeEskWOPhZEj/T+Vv1Ur9yXbRFeuSrtNbHBqGyr+3Wn/tL9bREQkkxTOEuna1X357a234PPP4bzz/K4kMGx2Qqa9Ts1x/D1CRUREWiyFs0RWrHAX4o8bB23b+lfH00/DAw8onNVhsyGgNsWRsz6bV/GHufcxZfCPeaez3WXpIiIiO0LhLJH334cf/9jdLbn77v7Vccst8Otf+9d/AMVSOLOsoVTXkJVH83i17VDWVRVq3ZmIiPhC4SyRcePg44/9v9eyuNh9yTah71en3SbdS9aPTrsHERGRzFA4S6RdOxgxwu8q3OM8vv8eJk3yu5LAMK1K0m5z8Lhb03o+P1pLbTifV177Vdp9iYiI7AiFs0RWr4ZXX4WxY/3dGPC3v8F77ymc1fHCoqlpt0nnhoDJ3z7DwKr/cc7O5+j6JhER8ZzCWSJffQUnnQQvvQSHHupfHQ89BDU1/vUfQDaBKW9Av5Sffa9oAF/ldcFUVitkiYiI5xTOEhk5EubP9/8Kp4IC9yU7xNmc+uL+t00vyAfSaCMiIpIpCmeJlJTAkCF+V+FOa1ZVwemn+11JYNiMZqU72lbs1BJD55yJiIj3FM4SKS+HZ5+FffeFAQP8q+Mvf4GNGxXOdlBagW7hQhg8GB5/PHsFiYiIJKBwlsiqVXDaafDYY/6Gs5kzIRr1r/8AsllzFu7aJeVn850Ix5buzQcXP8f9P/1p2n2JiIjsCIWzRPr2hUWL/L/CKRRyX7JNOkFrq3SO34gA/yjdD7C7jQDSP1dNRERkK4WzRAoKYKed/K4C/vQnaNMGNIKzjc05Z7Xd26X1fFG0hra1m5m+SCFLRES8pXCWSHW1u+Zo9GgYNsy/Ov78Z+jVS+GsjnR2Xm6VvyK95y9dOYOhVd9xaGhp2n2BzjkTERF7CmeJVFXBWWfB7bf7G87mzAHH8a//HBFZvCSt559zuvAObZjlKGSJiIi3FM4Sad0ali2D9u39rgSMjnTw2mcm/cvVRUREMkHhLJFQCHr39rsKuOUW91iH44/3u5JmLXbgyLSeD8ei9KpcC2vWQKdOWapKRESkMYWzZO691738fO+9/avhoYfg8MMVzuqw2RCQ9gXmS5dCv37w9FDdayoiIp4yTjNez1RWVubMnj07ex0UFsKll8JvfpO9PiRttpeRpyPkOIzlW+bTkZWmVdrttSFAREQaMsbMcRynrKnnNHKWzLJlUFrqdxXig5gxvEofhSwREfGcwlkyfh9AC3DZZXDQQXDEEX5XEhh5A/p50k/n2g3w7rswZown/YmIiIDCWXIPPODeFHDYYf7V8PDD0Latwlkd6R6LARAeukvabU764UM49mn3Ki8RERGPKJwlc8MN7mJ8P8PZ2rX+9Z1DZn52c/qNPj8JysszX4yIiEgSCmfJzJ/vbgqQQLG5W/OwPa636sv5eD4wLe12WqsmIiK2FM6SadvW3/4rK+GSS+AnP3HXnQlgd6m4TTjLj0WYMXMSDBrkHqshIiLiAYWzZB5+2N2tecIJ/vRfVQVPPw2jRimc1WFzlIbNaFtprNKd1p42DX75y7Tbi4iI2FA4S+b3v4eePf0LZ+3bw8qV/vQdYDZBy0a5KYI334QhQzzpT0REBBTOknvnHcjTX1EusLlVAID9989sISIiIk1Q8kimuNjf/leuhKuvhrPP9vcKqYCxWXNmbd48+Oord92fiIiIBxTOkpk+3V33deaZ/vS/cSPMmgXHHONP/znE9sqnWRf1hD//GU48EYzJcFUiIiKNKZwl89hjsG6df+Fs4ED49lt/+s4x1rcKXHGJe7+qiIiIRxTOkpkxA0Ihv6uQDLC5VQCAHj0yWoeIiEhTFM6SCYf97f+rr+DGG+Gqq2C33fytJUAmDJycdhvrHZ4VFfC3v8Gee8Lw4XbfISIikgaFs2SeegqWLoXLL/en//Xr4b333LVnso2zuSLtNtGVlvdjxmJw1llwyy0KZyIi4gmFs2RmzHDDkV/hbPRo+O9//ek7wGyClvXIWWkpfPMN9Opl115ERCRNCmfJPPyw3xVIHDb3Vo7vfr59h7q6SUREPKTV7kH2wQfu+VpLl/pdSbNnWpVYvQB4/XW4/XZf6xcRkZZDI2fJPPusG5BuucWf/svL4fPPoabGn/4Dyqu7Nbd56SW44w64+GL/N4mIiEjOM47j+F2DtbKyMmf27NnZ6+Cqq+Avf9H9lgFjM0W5Q7cKbNoEhYWQn2//HSIi0uIZY+Y4jlPW5HMKZ9LceDly5ulVUSIiktNSDWea1gyyF16A++5zR+/at/e7msDwfEPA5s0wdSocdBAccID994iIiKRA4SyZWbPgmWdg2jTI8+GvauNGWLIEmvHoZlDs0AhYQQHceiuUlCiciYhI1imcJfPFF+7p8FOm+BPOfvIT9yU7zPri89hT7lqzzZu15kxERDyhNWciIiIiHtCas1wwfTo8/jg895yOcNhBOzRyBvCf/8DLL8Ndd2WwKhERkcYUzpJ55x145BG47Tbo0MH7/isrYe1aCOms4Lo8P+cM4LPP4J//dDcGFBTs2HeJiIgkoWnNZJ54Ai691D2Itnfv7PUjwec4YIzfVYiISDOmac1MOOkk9yXNnu1RGtt2eSqYiYiIRxTOguyuu9x7HZ9+2u9KAsVmWtPmbLR6Kivh/PPh6KPh2GN37LtERESSUDhLZt4894yz66+Hfv287z8ahUjE+34DziZo7fCGgKIiNyiPGGH1PSIiIqlSOEvmhx/gtdfgkkv86f/SS92X1GMbtHaIMbB4sff9iohIi6NwlsxBB8HSpX5XIQ3s8BSliIhIgCmcBdk117jXNz3+uN+VtFh1R+nGOcsYx7dcx5gmNwgoQIqIiC2Fs2QWLYJrr4Urr/RnrVFBARQWet9vwO3QJeZpqheyHngAHnyQWa8+6t6zKSIikgUKZ8lUVMCcObB+vT/9X3edP/0GXHTlKn86njTJfYmIiGSRwlkyw4fDV1/5XYU0oClDERHJZQpnQXb22e7VTffe63clgeLlbs16QbCmBo48EiZOhDPP9KwGERFpWRTOklm50j149PzzYdw47/tv3173asZhdc7Z3jfueMcFBRCLuVc5iYiIZInCWTLRKCxYAOXl/vT/29/6028OyluzMTNf9PLLmfkeERGRBBTOkunRAz7/3O8qpAFfrm8SERHxiMJZkB1zDAwaBFOn+l1Js7fD1zdt9eCDcOed8OmnmnIWEZGs0G+XZCor4aij4F//8qf/Pn2gWzd/+pb4OnSAIUNg82a/KxERkRylkbNkQiH47jvYmKH1Sun6wx/86TfgvLz4vJHjjnNfIiIiWaJwlkxhIcyd63cVkgFacyYiIs2FwlmQ7bWXe67Wtdf6XUmg+HbOGbg7eIcPh1NPhauv9qwOERFpORTOmnLUUXD00f5c27PbbtC7t/f9BlzegH5pt3lhUYY2VYTDMGYM9O+fme8TERFpQOGsKRUVUF3tT98PPuhPvwEXWbwk7TYZ260J7gXoIiIiWaJw1pRXXvG7AsmAcNcumf1CxwFjMvudIiIiKJwFVyzmTp1dfjlceKHf1QSK74v777kHrrwS1q51N42IiIhkkM45a8pJJ8FvfuN9v7GYe59n377e9y3JDR0K55zj33S3iIjkNI2cBVVeHjz8sN9VSDxjx7ovERGRLFA4a8oTT/hdgQSR40BtLRQU+F2JiIjkGIWzoFq1CnbfHaZMgZ/9zO9qmr2M7tZ0HOjcGc46C267bQcrExERqU9rzppy5plwySXe95uf756vpjVnwXL99e61XmvXwm9/6+7YNMZ9X0REJAM0ctaU0lJo1cr7ftu3h/vu877fHJWxozSuv15BTEREsso4juN3DdbKysqc2bNn+12GtESOA5GIO8IpIiKSAmPMHMdxypp6TtOaQfX559CxI8yY4XclEs+oUXDCCX5XISIiOUjTmk25+GJYvRqmT/e237Zt4eSTdbdmHDaL+zN+cO3//R+0aZPZ7xQREUHhrGkdO7oLwL3Wuzfcfbf3/TYDvt8QADBpkt8ViIhIjsp6ODPGhIHZwHeO4xxpjOkPPAF0AOYCP3Mcp8YYUwg8CuwBrAUmOo6zJNv1Nenaa/2uQIKothZqavzZLCIiIjnNi5GzXwJfAlvngH4L3Ok4zhPGmHuBM4E/bfnnOsdxBhpjTtry3EQP6gumV16BY46Bl1+Gvff2u5pAsT2zzEbCUbpTToEvvoD58z2rRUREWoashjNjTC/gCOAW4FJjjAEOAk7Z8sgjwPW44eyYLX8G+AdwtzHGOH5vJ73mGnj/fTckealnT/f+xm7dvO23GQjEtOapp8KaNX5XISIiOSjbI2fTgCuA1lt+7gisdxwnsuXn5UDPLX/uCXwL4DhOxBhTvuX5er8BjTFnA2cD9OnTJ6vFA9C9OwwcmP1+Gho8GG6/3ft+m4FAbAg45pjMfp+IiMgWWQtnxpgjgVWO48wxxozd+nacR50UPtv+huPcD9wP7jlnGSg1ufPPz3oX0gxVVcGmTdCpk9+ViIhIjsnmyNm+wNHGmB8BRbhrzqYB7YwxeVtGz3oB3295fjnQG1hujMkD2gI/ZLG+YPvrX+H00901TX6M3AWYzShYRu/WBLjhBndks6bG6ntFREQSyVo4cxznauBqgC0jZ5c7jvNTY8xTwAm4OzZ/DjyzpcmzW35+b8vnr/q+3gxg6lR45BH3UFgv7borXHopdOjgbb/NgJcbAhI66ijo0cO9KcDEG/QVERGx48c5Z1cCTxhjbgY+Bh7c8v6DwGPGmEW4I2Yn+VBbY717Q1mTNy1k3siR7ksyIuNrzsaMcV8iIiIZprs1gyoWc0dkNCqTERmf1qyqgh9+gC5dIE9nOYuISNNSvVtTv1WCato0uOwyWL/evcpJdkjGR86mT4ezzoIlS6Bv38x+t4iItGgKZ0154AG48UZYsMDb0+D33huuuw6Ki73rM4dlfORsv/3gvvugXbsdqEpERKQxhbOm9OkDhx3m/fSi1jRlVMZHznbZxX2JiIhkmMJZUw4/3H15rbbW/Wd+vvd9S9Oqq2HFCnfNWUmJ39WIiEgOUTgLqmuvhTvvdEOA7LCMT2t++CEccIB7rdfBB+9AZSIiIvWF/C4g8J56yh0dWbrU234PPxxuvtnbPiV1u+wCDz3knkcnIiKSQRo5a0qfPnD88d4vzB83zn1JRmR8zVmXLu4NDiIiIhmmcNaUvfZyX16rqHBPn/dyh2gOy/i0ZiQCixdD587Qvv0OVCYiIlKfwllQXXABzJoF337rdyU5IeMjZ6tXu1Obf/oTnHtuZr9bRERaNK05a8rLL7tnWX30kbf9TpzobgqQYOrQAR5/XJsBREQk4zRy1pReveDnP4dOnbzt14/jOyR1hYXw05/6XYWIiOQghbOmDB4Md93lfb/r17sH3+rqJl8lW6vWx9nAZvJZaxpvFsn4NKqIiLQYCmdBdeqp7iGnc+b4XUmLljRklZbCOefA7bd7V5CIiOQ8hbOmzJvnXqP05JNw5JHe9Xvuue6OTcmI8d3Pt2o3c8U9iT+cPh0GDLCsSEREJD6Fs6Z06eLunOzf39t+vQyCLUB05arMf+kxx2T+O0VEpMUzjuP4XYO1srIyZ/bs2X6XkR0rV7r3anbo4HclksiXX0I4DIMG+V2JiIg0A8aYOY7jlDX1nEbOguqoo9wdos8/73clksgpp0Dv3vDss35XIiIiOUThrCnLl0O/fnDvvXDWWd71+6tfQVGRd/1J+u66C0pK/K5CRERyjMJZU9q2hSuvhN1397bfY4/1tr8cl5UNAQccYFmNiIhIYgpnTWndGm65xft+ly5179X0+vDbHJWVDQELF8KmTbDHHpn/bhERabEUzlIRjbr/DIe96/PAA2HsWHj4Ye/6zGFZORT2mmtg/nz44ovMf7eIiLRYaYUzY0wIKHUcZ0OW6gmeqiooLoZbb4Wrr/au39tvh65dvesvxyU76T+ZpKHummugstKyIhERkfiaDGfGmL8C5wJRYA7Q1hhzh+M4U7NdXCAUFMANN8D++3vb7/HHe9tfjsvKyJnX6xBFRKRFCKXwzJAtI2XHAs8DfYCfZbWqIAmF4LrrYL/9vO13wQJYvdrbPiU9ixfDK6/4XYWIiOSYVKY1840x+bjh7G7HcWqNMVkuK2CqqtxLyAsLvetz5Ei48EKYMsW7PnNYVqY1//xnmDoVamstqxIREWkslXB2H7AE+AR40xjTFyjPZlGB06ULnHkm3Hmnd30++ijsvLN3/eW4rExrTpoERxwBjuOGdxERkQxIJZz9x3Gc32/9wRizDDgjeyUF0I03wrBh3vZ5ot1Ij8SXlZGz/v29v3NVRERyXpN3axpj5jqOM6rBe3Mcx/H9cKecvVszFoNPP4WePaFzZ7+rkUSWL4d58+CQQ3Sbg4iINCnVuzUTbggwxgw2xhyPuzvzx3VevwBa1m+ijRvdw0a9snmzu+bskUe861PSN2uWewfqypV+VyIiIjkk2bTmLsCRQDvgqDrvbwQmZbOowBk5EvbaC6ZP96a/oohRFLYAACAASURBVCJ4+mkYOtSb/lqArExrHnEEfPghdOtmWZWIiEhjqUxr7uM4znse1ZMWz6Y1H37YPRB2woTs9yUiIiI5KdVpzVQ2BCwyxvwK6Ff3ecdxWs6mgF/8wtv+qqvdtUwDB0LHjt72naNsR86SaeNUM4w1zKcj6039mf6s7A4VEZEWIZVw9gzwFvAy7i0BLc+6de5xCR06eNPf8uWw997ucRo/aznn/WaTbVhKFup6s5HreY8r2Z+5LWwZpoiIZE8q4azEcZwrs15JkB1xBLRq5S4A90K3bjBjBgwf7k1/klDSULdpE/z3v/x2p52gtNS7okREJKelEs6eM8b8yHGc57NeTVBNngx5ad0Rv2NatYIf/ci7/lqAbExrJqNpTRERsZVK4vgl8CtjTDVQCxjAcRynTVYrC5LjjvO2vw0b4JNPYLfdoH17b/vOUeGuXazazVxxT+IPKyrg2WehrMxdHygiIpIBTV587jhOa8dxQo7jFDuO02bLzy0nmAGsXQsrVnjX3+efwwEHuMc0SHBt2AAnn+zddLeIiLQITY6cGWMOiPe+4zhvZr6cgDrzTFiyxN1B6YUhQ9xf+CNHetNfCxBduSrzX9qpE8yfDz16ZP67RUSkxUplWnNynT8XAaOBOcBBWakoiC64wL0lwCvt2rlXAkmw5eW5QVpERCSDmgxnjuPUvR0AY0xvYErWKgoir4PS6tXu3ZqjR0Pr1t72naOytkB/+nQYNAj23DM73y8iIi2OzRbE5cBumS4k0FavdkfOBgzwpr933nE3Icydq6nNDMnK9U0A554LkyYpnImISMaksubsD8DWO55CwAjgk2wWFTi//jU89xx8/703/e2/P7z5Juy8szf9ib1PP3WnoUVERDIklZGzupdXRoC/OY7zTpbqCaYzzoDDD/euv44d3YAmwde/v98ViIhIjkllzdkjxpgCYNCWtxZmt6QA2ntvb/tbtszdBTh2LBQXe9t3jsramrN//tM9NHj8+Ox8v4iItDhNnnNmjBkLfA3cA/wR+CrR8Ro5a9Uq9+wxr8yc6d4Q8MMP3vUpdm6+Gf74R7+rEBGRHJLKtObtwGGO4ywEMMYMAv4G7JHNwgLl97+H226DSMSb/o491r1Xs3Nnb/oTezNnQmGh31WIiEgOSSWc5W8NZgCO43xljMnPYk3BM3EijBgBjgPGZL+/Ll3clwRf165+VyAiIjkmpQ0BxpgHgce2/PxT3ENoW45hw9yXVxYuhAUL4MgjIRz2rl9J3wsvuNd7nXqq35WIiEiOSCWcnQecD1yEe+n5m7hrz1qO1avdRfq77+6eCp9tTz0F114LNTUKZxmStXPOHn7YPU5D4UxERDLEOI6T/AFjWgFVjuNEt/wcBgodx6nwoL6kysrKnNmzZzf94I76/e/hl7+ENWvcYy6ybeVK90y1ESO8mUYVe+Xl7r+jNm38rkRERALOGDPHcZyypp5LZRjoFeAQYNOWn4uBl4Ax9uU1M0ceCf36QWmpN/117aq1TM1F27Z+VyAiIjmmyaM0gCLHcbYGM7b8uSR7JQXQgAFw9NHe7cqbOxeeftqbvmTHvPkm3HGH31WIiEgOSSWcbTbGjNr6gzFmD6AyeyUF0Nq18N57UOnR/+yHH4Yzz/SmL9kxL74IV1zhdxUiIpJDUglnFwNPGWPeMsa8BfwduCC7ZQXMrFkwZgwsXepNf7/+Nbz7rjd9yY655hrYsME9ZkVERCQDUrm+6SNjzGBgF9zdmgscx6nNemVBcuCB7mGjvXp505/WnDUful5LREQyLKVzIbaEMQ/vLwqY7t3dl1fefBPWrYNjjvGuT7Ezbx785z/ubl7t2BQRkQxIZVpT1q2DN95wj03wwj33wJVXetOX7Jh58+C669x1iSIiIhmgcJaKuXNh7Fj45BNv+vvDH9yF5hJ8p54KtbXQv7/flYiISI5IOK1Zd4dmPI7jzM18OQE1ahS8+qp7GbkXdK9mUjan/Td50r8tL26MEBGRFiXZb5bbt/yzCCgDPsHdEDAc+ADYL7ulBUj79jBunHf9zZjh7v478kjv+mxGbIJW1q5v+uYbeOghOOMMjZ6JiEhGJAxnjuOMAzDGPAGc7TjOZ1t+3g243JvyAmLjRnj/fXfkzItdlL/7HcRiCmcZlLWRs+++g1tucae9Fc5ERCQDUpmTGbw1mAE4jvO5MWZEFmsKniVL4LDD3AvJTzgh+/099RREo9nvpwXJ2sjZvvu6/650B6qIiGRIKuHsS2PMn4HHAQc4Ffgyq1UFzYAB8PbbMHiwN/116uRNPy1I1kbOFMpERCTDUtmteTowH/gl7m0BX2x5r+Vo1codIenY0Zv+nnjCPfRWgq+83D325IMP/K5ERERyRCo3BFQZY+4FnnccZ6EHNQVPVRW88goMHQr9+mW/v5tugiFDYPz47PclO6aqCqZNg513hr328rsaERHJAU2OnBljjgbmATO3/DzCGPNstgsLlPJyd3H+Cy9409/bb8MDD3jTl+yYrl2huhrOOsvvSkREJEeksubs/wGjgdcBHMeZZ4zpl72SAqhDB/jwQ29GzcA9ukNERERapFTWnEUcx/Ho3qKAys+HPfeEzp296e/ee91pVGkeJk+GZ57xuwoREckRqYSzz40xpwBhY8zOxpg/AO9mua5gicXgX/+CL77wpr9rr3X7k+Zh+nT46CO/qxARkRyRSji7EBgKVAN/Bcpxd222LMcf754/5oXFi2HqVG/6kh33/f9v777jrKju/4+/Pyy9F6lSVJoFKboWFLsoVkwQ1NgVS/Rr7IaIBbtJVCJRMSqWKEYRe42IBWwoIFIUAyIKiKCConR2z++Pc/e3C1L2zp3Zmbn7ej4e89ide2c+82EY7v0w58w530o33hh3FgCAPFGePmednXODJQ2OOpnEqlJFmjJFatmyYo5Xr17FHAcAACROee6c3WFmM83sBjPbKfKMkqpbt4qbkPzWW/0Tm0iHm27y/QQBAAjBFouzzByb+0v6XtJ9ZjbNzK6KOrHEeeaZiulXVFws/eUvPBCQJmPH+rlXAQAIgTnnyr+x2c6SrpB0nHOuemRZlVNhYaGbOHFixRysaVNpwADp7rujPY5z0po1flqg6rGfYgAAEBIzm+ScK9zSdlvsc2ZmO0g6TtKxkn6U9ISkS3POMG3ef19q0CD645hJNWpEf5xKJrKJzwEACFl5+pw9JGmppEOcc/s554Y75xZHnFfydOxYMX3OVqyQhgxhaIY0uece6arK19IPAIjGZu+cmVmBpC+dc3dWUD7J9dxz/s7ZAQdEe5xly6TrrvPTAu22W7THqkQivQM2bZo0a1Z08QEAlcpmizPnXJGZNTGz6s65NRWVVCINHiztsEP0xVmLFlJRUbTHQLiGD487AwBAHinPOGdfS3ovM9n58pIXnXN3RJZVEr32mlSzZsUcq0p5WpsBAEA+Kk8V8K2klzLb1iuzVC5t2lTM3JqLFklXXilNnx79sRCOJ56QTj017iwAAHlii3fOnHPXSZKZ1XHOLd/S9nnrxRf9MBdHHx3tcb7/3k/dVFgodekS7bEqkUif1pw/X6qoIV0AAHlvi+OcmVlPSSMk1XXOtTWzbpLOcc6dVxEJbk6FjnN2wAF+gNh33qmY4wEAgLwS2jhnkv4h6VBJL0iSc+5TM9s3x/zSZ9Qo+oIBAIDIlavacM7N2+Clyvc4YdOmUpMm0R9n9mzpssukL7+M/lgIx9ix0u9/L/34Y9yZAADyQHmKs3lmtpckZ2bVzewySZ9HnFfyvPqq9Nhj0R9n/nw/ifZ330V/LIRj2TJfVK9aFXcmAIA8UJ4+Z1tJulPSwZJM0uuSLnTOxX6boEL7nA0Y4Acb/bzy1aUAACB3ofU5c879IOnEULJKswce8E9rAgAARGiLzZpm9jczq29m1cxsrJn9YGYnVURyiVK/fsVMfD5pkvSnP9GsmSbTpklHHul/AgCQo/L0OTvEObdM0pGS5kvqJOnySLNKorFjpbvvjv44c+f6vm2//BL9sRCOdeukhQullSvjzgQAkAfKU5xVy/w8XNJ/nHNLIswnuZ59VrrmmuiP06+ftGSJ1LFj9MdCOHr08Hc8d9897kwAAHmgPMXZi2Y2U1KhpLFm1lRS5Xss7e9/l+ZtOKIIAABAuLZYnDnnBknqKanQObdWfvLzvlEnlji1akm1a0d/nDfflM45R/r11+iPhXB8/710yCHSyy/HnQkAIA+U54GAmpJOl/SUmT0t6RxJP0WdWOKMHy/deGP0x5kzR3r+eamo8o3zm1oFBb6P4Nq1cWcCAMgD5RnnbJSkXySVjMB6gqRGzrlgM0mHqELHObv+eunaa33n74KCijkmAADIG+Ud56w8xdmnzrluW3otDhVanJXcFalaVTKrmGMCAIC8Ud7irDwPBHxiZnuWCbyHpPdySS6VqlXzS9SF2dNPS2eeGe0xEL7evaXhw+POAgCQBzY5Q4CZTZPk5IfSOMXMvsm81VbSZxWQW7J89JH04ovSoEFSnTrRHeerr6S3344uPqLBHVUAQEg22axpZu02t6Nz7utIMspChTZr3nuvdN550oIFUsuWFXNMAACQN3Ju1nTOfV2ySGoo6ajM0jAJhVmFO+ccqbiYwgwAAESqPENpXChppKRmmeUxM7sg6sQSp6KarO6/39+hQ7qceKJ0xRVxZwEAyAPleSDgTEl7OOeucc5dI2lPSWdFm1YCTZvm+5stWhTtcb7+Wpo6NdpjIHwNGkj16sWdBQAgD2zygYAyTFLZEVGLMq9VLrNnS0OH+jskzZtHd5yKGOgW4bvnnrgzAADkifIUZw9JmmBmz2bWj5E0IrqUEup3v5NWr447CwAAkOfKM7fmHfLTNy2RtFTS6c65f0SdWKV1663SZZfFnQWydeml0rHHxp0FACAPlOfOmZxzkyVNjjiXZPvyS+muu3xn/Y4dozvOt99KCxdGFx/RaNaMuTUBAKEoV3EG+QcBRoyQ+vaNtjgbNiy62IjOn/8cdwYAgDxBcVZee+0lLVsWdxYAACDPlWcoDVSkyy+Xrrkm7iyQrTvukLp3jzsLAEAeoDgrr+++k84/X4p6uqjvv5eWLIn2GAhfixZSly5xZwEAyAObnFszDSp0bs0vv5T23FP617+k3/++Yo4JAADyRnnn1qTPWXm1b+/vagEAAESIZs2kOfVU6a9/jTsLZOvJJ6VttvHN3wAA5IDirLx++UU66yxp7Nhoj7NiBTMRpFGLFtJ++0kFBXFnAgBIOZo1y6u4WHr5Zd/vLEpPPRVtfERjv/38AgBAjijOyqtBAz96PwAAQIRo1kyaww6T7r477iyQrfffl1q1kj74IO5MAAApx52zbJx6qnTUUdFOcG3mF4Sqd5X+gfYbU1zOZuattpKOOEJq2DDQcQAAKEFxlo3335e6do32GK+8Em38SqrcRVZQnTpJ998f7TEAAJUCxVk2Zs2KOwMAAJDn6HOWJGvWSHvsIT36aNyZIFsLFvimzX//O+5MAAApR3GWjXPPle67L7r4RUVSo0ZSjRrRHQPRqFdPOu44P5MEAAA5oFkzG599JjVrFl38WrWk116LLj6iU78+T9kCAEJBcZaNcePizgAAAOQ5mjWTZOFCqXt36fnn484EQTRtKl11VdxZAABSjuIsGxdfLN1yS3Txq1SR2rWT6taN7hiIzpln+gc6AADIAc2a2ViwQHIuuvjNm3PXLM1uvTXuDAAAeYDiLBujRsWdAZLOOWZ4AADkhGbNJJk+XdppJ+mdd+LOBEHsuqs0YEDcWQAAUo47Z9kYPFhatUq6/fZo4teoIe24ox8zC+lz6qlSkyZxZwEASDmKs2z8/LMvzqLSsaP0VMRzQCI6f/pT3BkAAPIAxVk27ror7gyQZM75WR6q8s8KABBcpH3OzKyhmY02s5lm9rmZ9TSzxmY2xsxmZX42ymxrZjbMzGab2VQz2yXK3BLp7belDh2kqVPjzgRB9Ovn+50BAJCDqB8IuFPSa8657SV1k/S5pEGSxjrnOkoam1mXpMMkdcwsZ0saHnFu2bv5ZumUU6KL36CBHyeLcc7S6fjjpT/+Me4sAAApF1n7i5nVl7SvpNMkyTm3RtIaM+sraf/MZo9IelvSnyX1lfRv55yT9GHmrltL59zCqHLM2tq10po10cXv0UMaOTK6+IgWT2oCAEIQZeeY7SR9L+khM+smaZKkCyU1Lym4nHMLzaxkJvGtJc0rs//8zGvrFWdmdrb8nTW1bds2wvQ34tprK/Z4SJeiIv/ASJ06cWcCAEixKJs1q0raRdJw51wPSctV2oS5MRsbufM3w/E75+5zzhU65wqbNm0aTqZJMWqU1LatNG/elrdF8gwa5OfXBAAgB1EWZ/MlzXfOTcisj5Yv1haZWUtJyvxcXGb7NmX2by3p2wjzy96wYVKfPtHFb9lSOugg7ryk1RFHSNdfH3cWAICUi6w4c859J2memXXOvHSQpM8kvSDp1Mxrp0oqmUzyBUmnZJ7a3FPSz4nqbyb5IRKqV48u/j77SA89JDVuHN0xEJ3995cuuyzuLAAAKWcuwom8zay7pAckVZc0R9Lp8gXhKEltJX0jqb9zbomZmaS7JPWRtELS6c65iZuLX1hY6CZO3OwmQMVZu1b69Vf/1G0VZkYDAKzPzCY55wq3tF2k3yDOuSmZ/mFdnXPHOOeWOud+dM4d5JzrmPm5JLOtc86d75xr75zbeUuFWV765z+lFi2kFSvizgRBPPigv+v53XdxZwIASDH+e5+Nhx+WCgv9HZIodOokHXNMtE2niM5ee0lDhzJOHQAgJ8wzk43ataXmzaXi4mjiH3qoX5BOO+/sFwAAcsCds2wMGCC9/LJUo0bcmSCJ1q6VFi2SVq+OOxMAQIpRnCXJ4MFSmzZb3g7JNH687zP44YdxZwIASDGKs2w884zUtau0ePGWtw2isFA64YRoYiN6228v3X23n7weAICA6HOWjXr1pPbtJdvYZAYh+N3v/IJ0atVKOu+8uLMAAKQcxVk2evf2CyqN3lX6l3vbKq5YTbRKv6qaXnDPRZgVACCfUZwlyRlnSB99JE2fHncmyBhT/FT5N543z8+Nev/90SUEAMh79DnLxtixvl/RZ59FE793b+nkk6OJjeg1aeILs332iTsTAECKcecsGw0aSN26STVrRhOfhwHSrXZtaeDAuLMAAKQcxVk2CgulJ5+MOwsk2Zw5/sGRpk3jzgQAkFI0ayZJnz5Sr15xZ4Fc7LCDdPvtcWcBAEgxirNsTJ4sbbedNG5cNPGPP1465ZRoYqNiPPywdNxxcWcBAEgxmjWzUb++v7PVsGE08U87LZq4qDj0GwQA5IjiLBsdOkj//nd08detkwoKohvkFtGbM8f/HbZrF3cmAICUolkzSXbbTerbN+4skIujj5YuuSTuLAAAKcads2zMneubNe+8U+rXL/z4f/yjH64DoctmpP+yshqEVvIPA9SvH+hYAABIFGfZqVtXOvRQqWXLaOKffXY0cZF9kRXUoYdWzHEAAHmL4iwbW20ljRgRXfzly6Xq1aVq1aI7RiVVYXfOvvpKWrFC2mmnQMcDAIDiLEk6dZIOP5y5GSNQYXfOLr7YPxQwdWrFHA8AkHcozrKxbJnUvr103XXSeeeFH//KK318pNeVV0orV8adBQAgxSjOslGzptS/v9S5czTxzz8/mrioOLvvHncGAICUozjLRvXq0j33RBd/6VKpVq3oJlZH9L75RlqwQOrZM+5MAAApxThnSdK0qXTDDXFngVzcdZd00EFxZwEASDGKs2w1ayZdc000sW+/XTriiGhio2Kceab04otxZwEASDGaNbN12ml+JP8oXHhhNHFRcTp3jq5PIgCgUqA4y9bf/hZN3OJiadEiP0NA7drRHAPR+/Zb6fPPpX328X0UAQDIEs2aSfHTT1KrVoxxlnYvvSQdfLD0/fdxZwIASCmKs2x17CiddVb4cWvVkoYPlw48MPzYqDhHHim9847UpEncmQAAUopmzWydeWY0A8XWqiWde274cVGxWrXyCwAAAVGcZWvQoGjirl3r+ys1bUqfszT78Ufpo4+kPfaQGjeOOxsAQArRrBmEc+HH/PJLaZttpOefDz82Ks7UqX5+VObWBAAERHGWrd12k44+Ovy4zZtLI0b4Oy5Ir112kT74wP8EACAAmjWzNXCgVLdu+HEbNZLOOCP8uKhYDRpIe+4ZdxYAgBSjOMvWOedEE3fFCj8nY+vW/uEApNOKFdIbb0jduknt2sWdDQAghWjWzFZRkbRmTfhxJ06UOnWS3n8//NioOD/+KPXtK73+etyZAABSijtn2TriCGnpUmnChHDjdu4sPfqotNNO4cZFxWrRQpo0ibtmAIDAKM6yddpp0sqV4cdt3lw66aTw46JiVavGwwAAgJxQnGXr+OOjifvzz9L8+X6A25o1ozkGKsbTT/uZJLp2jTsTAEAK0ecsW6tXS7/8En7cMWOkLl2k2bPDj42KdeKJ0siRcWcBAEgp7pxl66yzpPHjpa++CjfunntKo0ZJbdqEGxcVb9IkqVmzuLMAAKQUxVm2TjhB2mef8OO2bi317x9+XFQ8HuoAAOSA4ixbhx0WTdzFi/04Z126+E7lSK8XX5Tq1ZP23z/uTAAAKUSfs2ytXCn98EP4cZ96yj/lt3Rp+LFRsa68Uho2LO4sAAApxZ2zbF19tTR8uLR8ebhxDz9ceu45qWHDcOOi4r30ErM8AAACozjL1jHH+OEuwrbttn5B+jEALQAgBxRn2erVyy9hmzfP9znbYw/JLPz4qDhvvOHHrevXL+5MAAApRJ+zbC1f7oso58KN+8ADUs+e4cZEPO65R7ruurizAACkFMVZtu6+2w97EfYUTiefLL36KnfN8sG//iWNHRt3FgCAlKJZM1uHHuo77VcN+dR16OAXpF/TpnFnAABIMe6cZatbN+nss6Xq1cON+7//SR98EG5MxOP996V77407CwBASlGcZevXX6U5c6S1a8ONO3SofxIU6ffcc9JFF8WdBQAgpSjOsvXUU34ojQULwo178cXS00+HGxPxuOqq8K8PAEClQZ+zbO2zj/Tww1KTJuHG7dTJL0i/+vXjzgAAkGIUZ9mKquP+lCn+CVCG00i/qVOl11+XzjtPql077mwAAClDs2a2li+Xvvgi/KE0brjBP2iA9JswQbr8cmnJkrgzAQCkEMVZtt55R9p+e2natHDj3nyz9Mgj4cZEPE4+WVq2TNp667gzAQCkEM2a2ereXXr8cWm77cKN27lzuPEQn5o1/QIAQADcOctWq1bSCSdIW20Vbtz33mOcs3wxd66/EzpvXtyZAABSiOIsWytW+A7fy5aFG3fQID8EA9Jv7lxp8GBp9uy4MwEApBDNmtn67DNpt92kF16QjjoqvLgPPBD+ZOqIxz77SKtWhT+LBACgUqA4y1b79tLo0VJhYbhx6XOWPwoK/AIAQAA0a2arUSOpXz+pZctw4/73v9JHH4UbE/FYulQaMkSaPDnuTAAAKURxlq3Vq6WJE6Xvvw837gUX+Pk1kX7Ll0vXXSd98kncmQAAUohmzWwtWuT7nI0YIZ1xRnhxX3pJqlEjvHiIz9ZbS0VFUhX+7wMAyB7FWbaaNvUPA3TrFm5c5tXMH2Z+AQAgAP5rn61atfxTmm3bhht39Ghp0qRwYyI+V10lvfZa3FkAAFKI4ixbRUXS++9L8+eHG3fgQOnRR8ONifgMGya9+27cWQAAUohmzWytWSPtvbd0yy1+4NiwTJwo1asXXjzEK+xBigEAlQbFWbZq1PDDXoTdR6xDh3DjAQCAVKJZM1tVqkiHHCJts014MZ2THnxQ+vTT8GIiXn/7m/Tww3FnAQBIIYqzIMaNk2bNCi/emjXSmWdKL78cXkzEa/RoaezYuLMAAKQQzZpBHHGEdNZZ0h13hBOvenU/WXb9+uHEQ/yY7QEAEBDFWRCvvCK1ahVePDOpXbvw4gEAgNSiWTOIffbxE6CHZfly6d57pc8/Dy8m4vWvf0k33xx3FgCAFKI4C2LcuHA77y9ZIv3xj9J774UXE/F6/31pzJi4swAApBDNmkGcfrrUs6f02GPhxGvVSlq4kHHO8skjj8SdAQAgpSjOghg9OtzO+wUFUosW4cUDAACpRbNmED16hNvn7Pvv/XQ/c+aEFxPxGjVKOu+8uLMAAKQQxVkQ48f7PkVh+eYb6cILpenTw4uJeH3xBX3OAACBmHMu7hwCKywsdBMnTqz4A/fs6Zs1//vfcOKtWyf9/LNUt66fHgoAAOQdM5vknCvc0nb0OQvioYekatXCi1e1qtSkSXjxAABAatGsGcT224fb52zuXOnvf5cWLAgvJuL15pvSiSdKy5bFnQkAIGUozoJ47z3p9dfDi/f559IVV0jz5oUXE/FatEiaMEFasSLuTAAAKUOfsyD69vWd+D/5JJx4RUXSypVSzZq+iRMAAOQd+pxFadgwX1CFpaDAPwwAAAAqPZo1g2jXTtpuu/DiTZvm52FcsiS8mIjX1KlS//7SzJlxZwIASBmKsyA+/FB6+unw4k2eLA0eLP30U3gxEa+VK6UZM6Rffok7EwBAytDnLIizzpJefln69ttw4jknrV3r+5tVoV4GACAflbfPGZVAEDfeKH3wQXjxzKTq1SnMAAAAxVkgzZv7fmdhee896dprpVWrwouJeC1a5J/qfeONuDMBAKQMT2sGMWmS7/B9+unhxPvwQ+n66/1YZ4hE7yr9A+03pvip4Af9+mvp11+D7w8AqJS4cxbEM8/4fmdhufRSqbhYql07vJiIV/Pm0pQp0jHHxJ0JACBleCAgiKVL/R2RNm0q/tgAACCVeCAgSo0ahVuYvfKKdNVV4cVDMhx5pPTQQ3FnAQBIGYqzID79VLr7bmnNmnDivfuudM894cRCcixb5sc7cUSmkgAAHpFJREFUAwAgCzRrBnHnndJFF/kR/Rs1qvjjAwCA1KFZM0oDB/qhEho0iDsTAACQZyjOgqhTR2rWLLxBYx9/3A+lgfxy2mnSkCFxZwEASBmKsyBmzpSGDg1vLszx46VRo8KJheRwzi8AAGSBQWiDmDxZuuQS6fDDpYYNc483fHjuMZA8jzwSdwYAgBTizlkQ/fr5u2YdO8adCQAAyDMUZ0HUqOEfBgirz9k990h//Ws4sZAcV1whnXJK3FkAAFKG4iyIuXN9MTV/fjjxxo+Xxo4NJxaSo3ZtqW7duLMAAKQMfc6CmD1bGjRI2msvqXXr3OP95z+5x0Dy8KQmACAAirMg9t9fWr5cqlkz7kwAAECeoVkziKpVfZNVWH3ObrhBGjYsnFhIjqFDpV694s4CAJAyFGdBfPedHzR25sxw4n3wgR+eA/mlQQOpVau4swAApAxzawYxdarUrZs0erQfVgMAAGALyju3Jn3OgujSRVq3TiooiDsTAACQZ2jWDKJKlXALs4suku6/P7x4SIYnn5R22EH68ce4MwEApAjFWRDLlklXXy19/HE48SZO9MNzIL80biztvLNkFncmAIAUoVkziOXLpZtuktq0kXbbLfd4776bewwkT+/efgEAIAsUZ0G0aCEVF8edBQAAyEM0awYRdjPVSSdJjz8ebkzE7913pfbtfbM1AADlRHEWxLp1flLrN94IJ960aX7sNOSXRo2knj2lOnXizgQAkCI0awZhJv3zn77D98EH5x7v009zj4Hk2Wkn6bHH4s4CAJAyFGdBFBRIK1fGnQUAAMhDNGvGbeVKqW9f6fnn484EYZs3T2rbVho1Ku5MAAApQnEW1F/+4qdvytW6ddI33/ix05Bf6tTxzd7MrwkAyALNmkE9+aRUVCQde2xucerVkz75JJyckCyNG0sPPhh3FgCAlKE4C2rOnLgzAAAAeYhmzbgtXCgddpj05ptxZ4KwOeebNG+6Ke5MAAApQnEW1JAh0gMP5B5n7VppyRJp9ercYyFZzKR+/aQuXeLOBACQIjRrBvXGG9KOO0oDB+YWp21bacKEcHJC8vzzn3FnAABIGYqzoJisHAAARIBmzbjNmCEdeKD08cdxZ4Io7L67dOqpcWcBAEgR7pwFdcstfqaAK67ILU5Rke93hvz0+99LLVvGnQUAIEUozoKaNEmqGsLp69pVGj8+9zhIpkGD4s4AAJAyFGdBhTE7AAAAwAYi7XNmZheb2Qwzm25m/zGzmma2rZlNMLNZZvakmVXPbFsjsz478/42UeaWGOPGSb16Sf/7X9yZIArHHivtsUfcWQAAUiSy4szMtpb0J0mFzrkukgokHS/pr5KGOuc6Sloq6czMLmdKWuqc6yBpaGa75LrzTunPf849TpUqUs2avv8a8s9RR0knnhh3FgCAFIm6WbOqpFpmtlZSbUkLJR0o6Q+Z9x+RNETScEl9M79L0mhJd5mZOedcxDkGM2tWOFM49erlx0xDfuJJTQBAliIrzpxzC8zsNknfSFop6XVJkyT95Jxbl9lsvqStM79vLWleZt91ZvazpCaSfigb18zOlnS2JLVt2zaq9LfsrrviOzbSpbjY3yEFAKAcomzWbCR/N2xbSa0k1ZF02EY2LbkzZpt5r/QF5+5zzhU65wqbNm0aVrrxefZZPxbW4sVxZ4IoXHqp1KhR3FkAAFIkymbNgyV95Zz7XpLM7BlJe0lqaGZVM3fPWkv6NrP9fEltJM03s6qSGkhaEmF+ubn/funDD6URI3KLU6OG1KSJVK1aOHkhWXr3lho3jjsLAECKRNnW8o2kPc2stpmZpIMkfSbpLUnHZrY5VdLzmd9fyKwr8/6bie1vJknffRfOE5aHHy69+ip3V/JVnz7S4MFxZwEASBGLsv4xs+skHSdpnaRPJA2U71v2hKTGmddOcs6tNrOakh6V1EP+jtnxzrnN9rgvLCx0EydOjCx/IGfOSatW+SdybWMt9wCAysLMJjnnCre0XaS9lJ1z1zrntnfOdXHOneycW+2cm+Oc290518E51985tzqz7arMeofM+yE8CpkC990ndevGFE756p57pNq1pe+/jzsTAEBK8AhZUI8/Lh19dO5xGjaUtt02nKmgkDw9e0o33yzVqhV3JgCAlKAiCGrZMmnBgtyHSRgwwC/IT7vs4hcAAMqJO2dBnXuun/yc8auwOUVFvpCn2RoAUE5UFnG78UbmXsxnb7whNWggffxx3JkAAFKC4iyoF16QDjnE3xXJxdZbS126hJMTkmeHHaTbbpPinM0CAJAq9DkLas0a6ddfpXXrtrzt5px+ul+Qn9q29bMEAABQTtw5C+rYY6X332f0d2xeUZH0ww/SypVxZwIASAmKs7hdcIGf4gf56euvpaZNpVGj4s4EAJASFGdBvfWWtP/+0ty5ucXZfntp113DyAhJ1KyZNGyYn9weAIByoM9ZUCVT8RQX5xbn/PNzzwXJVbeuvzsKAEA5UZwFtf/+0ttvx50Fks45aeFCP4VTw4ZxZwMASAGaNeN27LFSv35xZ4EotWnjh9MAAKAcKM6CmjzZz5s4eXJucfbc0y/IT2bSv/4l9e0bdyYAgJSgWTOoqlWlevVyn77pssvCyQfJNXBg3BkAAFKE4iyorl2l11+POwukwfz5UkGB1LJl3JkAAFKAZs249eolnXFG3FkgSgcfLF10UdxZAABSguIsqC+/lAoLpTFjcovTp4+0117h5IRkuvVWhkwBAJQbzZpBVa8utWgh1aiRW5yrrgonHyTXMcfEnQEAIEUozoJq00Z66aW4s0AazJ8vrV4ttW8fdyYAgBSgWTNu22wjXXJJ3FkgSueeKw0YEHcWAICUoDgLaskSaeedpf/8J7c4J58s7b13ODkhma64QrrllrizAACkBM2aQVWrJnXsKDVokFucG24IJx8k1777xp0BACBFKM6CqldPeuaZuLNAGnz7rbR4sdS9e9yZAABSgGbNODnnn/q88ca4M0GU/v537p4BAMqN4iwo56TOnaU77wweo7jYT9/Us2d4eSF5zjgj976JAIBKg2bNoMz8ILStWgWPUVAg3XxzeDkhmXbe2S8AAJQDxVkuRo7MbX/n/E+z3HNBci1eLM2eLe22m3+QBACAzaBZM06LF0tVqkjDh8edCaI0erQfLmXJkrgzAQCkAMVZLgoLpcGDg+9fu7Z07bU+DvLXkUdKr72W+7ArAIBKgWbNXOy1l9SpU/D969WThgwJLR0kVNu2fgEAoBwoznIxbFhu+xcXS2vX+n5IVbiJmbeWLpWmTvXjnHH3DACwBVQEcZoxQ6pZk8Fs893HH0v77y9Nnx53JgCAFKA4y8UBB0gDBwbfv1kz6aabpC5dwssJyVNYKL35prTTTnFnAgBIAZo1c3HAAVLz5sH3b95cuvLK8PLBJvWu0j/QfmOKn8r94I0b+2sFAIByoDjLxTXX5Lb/2rXSqlX+qc2CgnBywkaFUmQFtWKF9N570o47SltvHV8eAIBUoFkzTuPGSfXr+y9u5K9Fi6RDDpHGjIk7EwBACnDnLBfHHCOtWSO98kqw/Tt0kG67TWrfPty8kCytWknjx+c27AoAoNKgOMvFQQdJRUXB92/XTrr00vDyQTLVqCH16hV3FgCAlKA4y8UFF+S2/6pV0vLlUsOG9DnLZ875u6vbbSftsEPc2QAAEo4+Z3F69llpq638pNjIb0cfLT32WNxZAABSgDtnuTjtNGnKFL8EseuufpaBXIbjQPKZSRMm+L5nAABsAcVZLg4+OLdmqk6d6CReWTC5PQCgnCjOcnHSSbnt/8svfmnRgrk1893rr/thU/bcM+5MAAAJR0UQpwcf9IOS/vxz3JkgahdeKA0dGncWAIAU4M5ZLi6+WBo5Ulq8ONj+Bx4o3XuvVKdOuHkheZ57jr9nAEC5UJzl4qCDpCZNgu+/885+Qf7r3DnuDAAAKUFxlosjj/RLUEuW+D5n7dqFlxOS6e23/Rybhx8edyYAgISjz1mucpkh4Pbb/RROyH+33y5ddVXcWQAAUoA7Z7m44QbpmmukdeuCjfDfrx/NXZXF8OFxZwAASAmKs1zst590/fV+ep4gdtnFL8h/rVvHnQEAICUoznKx775+CWrhQmnlSj/nIvLbhAnS//4nnXxy3JkAABKOPme5KCrynbyLi4Ptf/XVuRV3SI8nn5TOOy/uLAAAKUBxlov77/djVy1aFGz/s8+W7ror3JyQTIMHSzNnxp0FACAFaNbMxZ57SrfeKtWtG2z/3XcPNx8kVy7j4QEAKhWKs1x07+6XoObM8U2jHTuGlxOSafp06Z13pDPPlGrWjDsbAECC0ayZi3Xr/LyY69YF2//CC6Xjjgs3JyTTuHHS//2f9NNPcWcCAEg4irNcvPCC1LChNGNGsP2vvFL6+9/DzQnJdOqpvm9is2ZxZwIASDiaNXPRtat0xx1Sy5bB9u/ZM9x8kFx16jDxOQCgXLhzlosOHaSLLw5+N2TGDGnWrHBzQjLNnSsNHerHtgMAYDMoznKxdq20eLG0enWw/c84Q7rggnBzQjLNmiVdcon05ZdxZwIASDiaNXMxYYK0zz7SmDHSwQdnv/8dd0hV+SuoFPbbT1q6VKpXL+5MAAAJR2WQiw4d/CCynToF23/vvcPNB8lVvbpfAADYApo1c9GihXT++VLbtsH2//hj+pxVFkuXSn/9qx/vDACAzaA4y8W6ddL8+dLy5cH2HzBAuuGGcHNCMv38szRokC/IAQDYDJo1c/Hll9L220sjR0p/+EP2+z/6qB8nDfmvbVtfxDM7AABgCyjOctGypZ/8POgcmb16hZsPkqtKFal27bizAACkAM2auahfXxo40D8YEMTbb0uzZ4eaEhLKOd+E/dZbcWcCAEg4irNcFBX5ycuXLg22/xFHSPfeG25OSCYz6frrpbFj484EAJBwNGvmYtkyqX17P/L7RRdlv//rr/snPlE5rFghVasWdxYAgISjOMtF3brSI49Iu+0WbH/GOatcKMwAAOVAs2YuqlWTTjlF2mGH7PctKpJeeUX66qvw80IyDR0qPfFE3FkAABKO4ixXM2dKixZlv9+qVb7P2VNPhZ8TkumBB6QXX4w7CwBAwtGsmauuXaXLLpNuvjm7/WrW9HNzbr11NHkheaZP9w8GAACwGRRnuRo5UurcOfv9CgqCj4+GdKIwAwCUA82auerf3989y9aKFdKzz0rffBN+TkimESOkf/wj7iwAAAlHcZarGTOkr7/Ofr9Fi6Tf/156883wc0Iyvfqq9PTTcWcBAEg4mjVzdeihUp8+vrN3Nlq1kj75RGrTJpq8kDyjR8edAQAgBSjOcvXAA1Lz5tnvV6OG1L17+PkAAIBUo1kzV336SD16ZL/fkiXSqFHSwoXh54Rkevpp6fLL484CAJBwFGe5mjFD+uKL7PebNUs67jhpypTwc0IyTZ5M0yYAYIvMORd3DoEVFha6iRMnxptEjx6+39gLL2S338qVfnaANm2kevWiyQ0AACSGmU1yzhVuaTv6nOXqn/+UatXKfr9ataQddww/HwAAkGo0a+aqVy9p112z32/+fOnRR6Uffww/JyTTm29KZ54pLV8edyYAgASjOMvV9Ol+SIxsTZ7sJ00PMkYa0umbb6TXXvMDEAMAsAn0OcvVoYdKP/8sffhhdvstX+6f1Gzd2s+zCQAA8hp9zirKrbdKRUXZ71enjtShQ/j5AACAVKNZM1c9ekiFWyyCf+uLL/xci7/8En5OSKapU31T9uzZcWcCAEgwirNczZghvftu9vuNHy8NHOibRFE5/Pyz/3vn7xwAsBn0OcvVySdL770nzZmT3X7Ll/snNVu1kqrSugwAQL6jz1lFueoq6ddfs9+vTh2/AAAAlEGzZq46dw42ztmkSdLw4dLateHnhGRauFA6/nhp3Li4MwEAJBjFWa4+/9yPXZWt//5XOu88KcXNyshSUZEfE2/JkrgzAQAkGMVZrh54QOrfP/v9LrpI+u47qVq18HNCMrVu7Z/SPeaYuDMBACQYxVmu/vQn6e23s9+vdm2peXPJLPSUAABAelGc5apdO9/nrEsX6eqrS1/v3Fm6/vrS9e22k265pXS9ZUvpzjsrLk8E0rtK/0DLRjknHXGEtNdeZQ7Q2w+pUmK//Xxzd4m99pIuvLB0vbBQuvzy0vWuXaXBg0vXd9hBGjKkdL19e+nmm0vX27SRbrvN/75unb+bV3Idrljh14cP9+s//eTXR4zw64sX+/VHH/XrCxb49See8OtffeXXn3nGr3/xhV9/6SW/Pn26X//vf/365Ml+/a23/PqHH/r1997z6+PH+/WPPvLrY8f69SlT/Pqrr/r1zz7z688/79dLxpEbPdqvl0yR9vjjfn3hQr/+8MN+vWR+2/vv9+vLlvn1u+/266tW+fWhQ/16cbFf/9vf/L//EjfeKHXsWLp+zTXSTjuVrg8a5MdFLHHppdLuu5euX3CBn6u3xDnnSAceWLp+xhl+RpISJ50kHXVU6fqAAVK/fqXrv/ud7+NY4ogj/Dh7Jbj2uPZKcO2Fd+2FhKc1gxoyRLruuvVfmzFDKijw7x18sLT99qXvHXKI1KnT+vtddJFfJOnaa9e/uJAIY4qfCifQhtdLyR3T/fZb/0Nzn338B0mJKlWkYcP8UmLSJP+k75Ah/gN0xx1L3yu57soeb/Dg0g+yHj1KZ6Ywk/r08R9kkr92mzXzH5JlPygHDpTmzZMuvthvX5JfzZp+vXXr9Y9X9kO6Rw+pRQv/e/36fvtmzfx6gwb+97JfApL/krj2Wv+B36eP1KiRf71pU7/+0EPrn4+SL6GBA/37JU9Bt2rl12vX9utjxvgP1lat1j/ebbf5/zhts43fvmRom2239es33eS//EoUFPifAwas/4XVubP/0ikxY4b/8t7w7viQIX7p0qU0liR16ybVrbvpa+Www9Yv7HfdVVq5snT9p5/8n3HD45VcDz17SvXqlb6+997+nJY93rhxpV9Se+/tvwRLHHDA+l/4tWv7L8CyX4IlcYYM8eeic+fS9/r08dfepj4De/Tw51zy3T369CktQGrU8NfKKaes/yV/wgnSzJn+eu3Tx/+nV/LnsU8ff+2VPV6fPqX79ujh//yS1Lixf69xY7/epIk/3h57rH8ue/Tw1+bRR/vtS85ny5al117Z422zzfr71qjhf2/b1m9fvXrpds2a+X8TZdWq5Y+3667r596xY+m1V/Z4Zf/uyxZfO+0krVlTut6liy9IN7xWzPzxunf3LTsldtml9O9iyBBp5MjfHu+gg0p/32OP9bvs9OzpxwPd8HgjRvjjbfi5t+++pcXmkCH+M2/SpNICS1p/hp0Nv2979/aFdNnjXX65X66++refe336+Guv7LkcOLC0gOzRY+Ofe5L/O2/WbP3PvRI5fK8zzhkAAEAFKO84ZzRrAgAAJAjFGQAAQIJQnAEAACQIxRkAAECCUJwBAAAkCMUZAABAglCcAQAAJAjFGQAAQIJQnAEAACQIxRkAAECCUJwBAAAkCMUZAABAglCcAQAAJAjFGQAAQIJQnAEAACQIxRkAAECCUJwBAAAkCMUZAABAglCcAQAAJAjFGQAAQIJQnAEAACQIxRkAAECCUJwBAAAkCMUZAABAglCcAQAAJAjFGQAAQIJQnAEAACQIxRkAAECCUJwBAAAkCMUZAABAglCcAQAAJIg55+LOITAz+17S15t4eytJP1RgOmnBedk4zstvcU42jvOycZyXjeO8/FZlPiftnHNNt7RRqouzzTGzic65wrjzSBrOy8ZxXn6Lc7JxnJeN47xsHOfltzgnW0azJgAAQIJQnAEAACRIPhdn98WdQEJxXjaO8/JbnJON47xsHOdl4zgvv8U52YK87XMGAACQRvl85wwAACB1KM4AAAASJC+LMzPrY2ZfmNlsMxsUdz5JYGZzzWyamU0xs4lx5xMXM3vQzBab2fQyrzU2szFmNivzs1GcOcZhE+dliJktyFwzU8zs8DhzrGhm1sbM3jKzz81shpldmHm9Ul8vmzkvlf16qWlmH5nZp5nzcl3m9W3NbELmennSzKrHnWtF2sx5edjMvipzvXSPO9ckybs+Z2ZWIOl/knpLmi/pY0knOOc+izWxmJnZXEmFzrnKOvCfJMnM9pX0q6R/O+e6ZF77m6QlzrlbM8V8I+fcn+PMs6Jt4rwMkfSrc+62OHOLi5m1lNTSOTfZzOpJmiTpGEmnqRJfL5s5LwNUua8Xk1THOfermVWT9K6kCyVdIukZ59wTZnavpE+dc8PjzLUibea8nCvpJefc6FgTTKh8vHO2u6TZzrk5zrk1kp6Q1DfmnJAQzrlxkpZs8HJfSY9kfn9E/oumUtnEeanUnHMLnXOTM7//IulzSVurkl8vmzkvlZrzfs2sVsssTtKBkkoKkMp4vWzqvGAz8rE421rSvDLr88UHh+T/MbxuZpPM7Oy4k0mY5s65hZL/4pHULOZ8kuT/zGxqptmzUjXflWVm20jqIWmCuF7+vw3Oi1TJrxczKzCzKZIWSxoj6UtJPznn1mU2qZTfRxueF+dcyfVyU+Z6GWpmNWJMMXHysTizjbxGlS7t7ZzbRdJhks7PNGMBmzNcUntJ3SUtlHR7vOnEw8zqSnpa0kXOuWVx55MUGzkvlf56cc4VOee6S2ot34qzw8Y2q9is4rfheTGzLpL+Iml7SbtJaiyp0nQNKI98LM7mS2pTZr21pG9jyiUxnHPfZn4ulvSs/AcHvEWZfjQl/WkWx5xPIjjnFmU+VIsl3a9KeM1k+sg8LWmkc+6ZzMuV/nrZ2HnheinlnPtJ0tuS9pTU0MyqZt6q1N9HZc5Ln0zzuHPOrZb0kCrx9bIx+VicfSypY+YJmeqSjpf0Qsw5xcrM6mQ67srM6kg6RNL0ze9Vqbwg6dTM76dKej7GXBKjpADJ+J0q2TWT6cg8QtLnzrk7yrxVqa+XTZ0XrhdramYNM7/XknSwfH+8tyQdm9msMl4vGzsvM8v8B8fk++FVqutlS/LuaU1JyjzC/Q9JBZIedM7dFHNKsTKz7eTvlklSVUmPV9ZzYmb/kbS/pK0kLZJ0raTnJI2S1FbSN5L6O+cqVef4TZyX/eWbqJykuZLOKelrVRmYWS9J4yVNk1SceflK+f5VlfZ62cx5OUGV+3rpKt/hv0D+xsco59z1mc/fJ+Sb7j6RdFLmblGlsJnz8qakpvJdkaZIOrfMgwOVXl4WZwAAAGmVj82aAAAAqUVxBgAAkCAUZwAAAAlCcQYAAJAgFGcAAAAJQnEGIFZmFsrj82Y2xMwuK8d2D5vZsVvarqLiZGKVK3cAlQPFGQAAQIJQnAFIBDOra2ZjzWyymU0zs76Z17cxs5lm9oCZTTezkWZ2sJm9Z2azzKzstC/dzOzNzOtnZfY3M7vLzD4zs5dVZqJyM7vGzD7OxL0vM1r5xnI7JTNB86dm9miZt/Y1s/fNbE7JXTQz29/MXiqz711mdlrm97lmdl2ZP+P2GznWWWb2qpnVMrM/ZfKeamZPBD+7ANKk6pY3AYAKsUrS75xzy8xsK0kfmlnJ1GsdJPWXdLb8FG1/kNRL0tHyo9Mfk9muq/x8hnUkfZIpxvaU1FnSzpKaS/pM0oOZ7e9yzl0vSZmi60hJL5ZNysx2kjRY0t7OuR/MrHGZt1tm8theflqn0eX4c/7gnNvFzM6TdJmkgWWO9X/y06sd45xbbWaDJG2b+b1hOWIDyAPcOQOQFCbpZjObKukNSVvLF1OS9JVzblpmUu0ZksY6P73JNEnblInxvHNupXPuB/k5DXeXtK+k/2Qm5f5W0ptltj/AzCaY2TRJB0raaSN5HShpdCamNpiq6TnnXLFz7rMyuW5JyQTqkzbI/WRJh0nqV2Z6n6mSRprZSZLWlTM+gJSjOAOQFCfKz7W3q3Ouu/wcnzUz75Wdi7C4zHqx1m8B2HA+OreJ12VmNSXdI+lY59zOku6XVNPM2pjZlMxyrnzRuKl57srmVdIkuk7rf7bW1PpK9inaIPfp8sVa6zKvHSHpbkm7SppkZrR2AJUAxRmApGggabFzbq2ZHSCpXYAYfc2sppk1kZ+4/WNJ4yQdb2YFZtZS0gGZbUuKph/MrK6kYyXJOTfPOdc9s9wraaykAZmY2qBZc2O+lrSjmdUwswaSDipn7p9IOkfSC2bWysyqSGrjnHtL0hWSGkqqW85YAFKM/4UBSIqRkl40s4mSpkiaGSDGR5JeltRW0g3OuW/N7Fn5pslpkv4n6R1Jcs79ZGb3Z16fK1/I/YZzboaZ3STpHTMrki+iTttUAs65eWY2Sr5JclZm+3Jxzr2bGVLjZfm+Z49lCjyTNNQ591N5YwFIL/PdNgAAAJAENGsCAAAkCMUZAABAglCcAQAAJAjFGQAAQIJQnAEAACQIxRkAAECCUJwBAAAkyP8Dik5EABtOHvkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x2160 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.gcf()\n",
    "fig.set_size_inches(10,30)\n",
    "plt.imshow(np.log(gw_hist[\"donut\"]),aspect=0.05)\n",
    "ax = plt.gca()\n",
    "ax.plot(np.arange(threshold_df[\"donut\"].values.size)-0.05,threshold_df[\"donut\"].values,color='r',marker=\"_\",linestyle=\":\")\n",
    "\n",
    "ax.set_ylabel(\"observed counts\")\n",
    "ax.set_xlabel(\"lambda-chunks\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**a histogram for a particular $\\lambda$-chunk**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "204896\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 1 artists>"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "binid = 7\n",
    "print(gw_hist[\"donut\"].iloc[:,binid].values.sum())\n",
    "hs = np.clip(gw_hist[\"donut\"].iloc[:,binid].values,a_min=None,a_max=10000)\n",
    "# hs = np.log(gw_hist[\"donut\"].iloc[:,binid].values)\n",
    "plt.bar(gw_hist[\"donut\"].iloc[:,binid].index,hs)\n",
    "plt.bar(threshold_df[\"donut\"].iloc[binid],hs.max(),width=10,color='red')\n",
    "# plt.gca().set_ylim(0,1)\n",
    "# plt.gca().set_xlim(0,60)\n",
    "# gw_hist[\"donut\"].iloc[:,20]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**now extract \"significant\" pixels using the defined thresholds_df and the same parquet file with the score dump as for the histogramming step**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Preparing to convolve 49 tiles:\n",
      "creating a Pool of 8 workers to tackle 49 tiles\n",
      "Number of filtered pixels 4013\n"
     ]
    }
   ],
   "source": [
    "filtered_pixels = dotfinder.scoring_and_extraction_step(clr,\n",
    "                                        expected,\n",
    "                                        expected_name,\n",
    "                                        balancing_weight_name,\n",
    "                                        tiles,\n",
    "                                        kernels,\n",
    "                                        ledges,\n",
    "                                        threshold_df,\n",
    "                                        max_nans_tolerated,\n",
    "                                        balance_factor,                \n",
    "                                        loci_separation_bins,\n",
    "                                        None, \n",
    "                                        nproc,\n",
    "                                        verbose)\n",
    "\n",
    "print(\"Number of filtered pixels {}\".format(len(filtered_pixels)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7f6c8071e1d0>"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xlabel = 'la_exp.donut.value'\n",
    "ylabel = 'count'\n",
    "\n",
    "# we might consider \"downsampling\" la_exp dataframe in order to make obs/exp scatter plot less busy:\n",
    "sub_la_exp = la_exp.sample(frac=0.1)\n",
    "\n",
    "sct = plt.scatter(sub_la_exp[xlabel],\n",
    "                  sub_la_exp[ylabel],\n",
    "                  # color dots on the scatter by their genomic separation\n",
    "                  c=sub_la_exp['bin2_id']-sub_la_exp['bin1_id'],\n",
    "                  vmin=0,\n",
    "                  vmax = 100,\n",
    "                  cmap=\"YlOrRd_r\")\n",
    "\n",
    "\n",
    "\n",
    "plt.scatter(filtered_pixels[xlabel],\n",
    "            filtered_pixels[ylabel],\n",
    "            s=80,\n",
    "            facecolors='none',\n",
    "            edgecolors='b')\n",
    "\n",
    "# we can add a visual of the lambda-chunking grid on top of obs/exp scatter ...\n",
    "# plt.vlines(ledges[1:-15],ymin=0.5,ymax=900,color='red')\n",
    "\n",
    "ax = plt.gca()\n",
    "fig = plt.gcf()\n",
    "\n",
    "ax.set_xscale('log')\n",
    "ax.set_yscale('log')\n",
    "\n",
    "ax.set_xlim(0.5,700)\n",
    "ax.set_ylim(0.5,1200)\n",
    "\n",
    "ax.set_ylabel(\"count\")\n",
    "ax.set_xlabel(\"la_exp value\")\n",
    "\n",
    "fig.colorbar(sct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clustering \"significantly\" enriched pixels\n",
    "\n",
    "**annotate filtered pixeles and cluster them -> get centroids after that to proceed with post-processing ...**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_pixels_qvals = dotfinder.annotate_pixels_with_qvalues(filtered_pixels,\n",
    "                                                                qvalues,\n",
    "                                                                kernels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/venevs/miniconda3/envs/dots-latest/lib/python3.6/site-packages/sklearn/cluster/birch.py:77: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  node1_dist, node2_dist = dist[[farthest_idx]]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clustering is completed:\n",
      "6296 clusters detected\n",
      "3.42+/-3.53 mean size\n",
      "\n",
      "Clustering is over!\n",
      "Number of clustered pixels, i.e. centroids 6296\n"
     ]
    }
   ],
   "source": [
    "filtered_pixels_annotated = cooler.annotate(filtered_pixels_qvals, clr.bins()[:])\n",
    "centroids = dotfinder.clustering_step(\n",
    "                            filtered_pixels_annotated,\n",
    "                            expected_chroms,\n",
    "                            dots_clustering_radius,\n",
    "                            verbose)\n",
    "print(\"Number of clustered pixels, i.e. centroids {}\".format(len(centroids)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_out = dotfinder.thresholding_step(centroids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2327"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(final_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Browsing \"called\" dots on a heatmap\n",
    "\n",
    "**stuff that require clean up, but might be usefull in general**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/venevs/miniconda3/envs/dots-stable/lib/python3.6/site-packages/ipykernel_launcher.py:11: RuntimeWarning: divide by zero encountered in log\n",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f3b8ccf1ac8>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plt.imshow(np.log(clr.matrix()[18030:18100,18030:18100]),cmap='YlOrRd')\n",
    "# plt.scatter(53,18,s=80, facecolors='none', edgecolors='b')\n",
    "\n",
    "bin1,bin2 = 18030+18,18030+53\n",
    "\n",
    "bin1_n,bin2_n = 18030+23,18030+49\n",
    "\n",
    "\n",
    "bin1,bin2 = 24322, 24334\n",
    "\n",
    "plt.imshow(np.log(clr.matrix(balance=True)[bin1-20:bin1+20,bin2-20:bin2+20]),cmap='YlOrRd')\n",
    "\n",
    "# something to have in mind - is the difference between JUicer balancing and cooler balacning ...\n",
    "# MAD max filtering in particular\n",
    "# in Juicer some of thesparse/low coverage regions are kept - what re the effects on the distriubtions, etc\n",
    "# to be seen\n",
    "# here is the region for reference: chr1:242,019,651-244,387,558 & chr1:242,713,339-243,695,154 [offset 0,0:0,0]\n",
    "\n",
    "dddd = cccc[(cccc['bin1_id']==bin1)&(cccc['bin2_id']==bin2)]\n",
    "eeee = cccc[(cccc['bin1_id']==bin1_n)&(cccc['bin2_id']==bin2_n)]\n",
    "\n",
    "(cccc['bin2_id']-cccc['bin1_id']).min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'la_exp value')"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEKCAYAAADn+anLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3X+U3HV97/HnazcDTEDZUCIlSzDIxVCQI2gK2HhawLaoVImiUq5W9HgPvad6FYrxBqUCipcoVu1PerBa8UJjwq+IxRYRYmnxBk3IhhBJKvIjyZJCqllEspDN5n3/+H4nzM7Od+a7m52d2f2+Hufs2ZnPfGfms5PJ9/39/Hp/FBGYmZnV09XuCpiZWedykDAzs0wOEmZmlslBwszMMjlImJlZJgcJMzPL5CBhZmaZHCTMzCyTg4SZmWWa0e4K7K/DDz885s2b1+5qmJlNKWvXrv2viJjd7LgpHyTmzZvHmjVr2l0NM7MpRdKTeY5zd5OZmWVykDAzs0wOEmZmlslBwszMMjlImJlZpik/u2kirFzXz7V3beapgUHm9JRZfPZ8Fp3S2+5qmZm1XeGDxMp1/Vx22wYGh4YB6B8Y5LLbNgA4UJhZ4RW+u+nauzbvCxAVg0PDXHvX5jbVyMyscxSyJVHdvZS1w/dTA4OTWiczs05UuCBR272UZU5PeZJqZGbWuQrX3VSve6lWudTN4rPnT1KNzMw6V+GCRLNupG6J817f60FrMzMKGCSadSMNR3Dr2n5WruufpBqZmXWuwgWJxWfPp1zqbniMZzeZmSUKN3Bd6Uby7CYzs+YKFyQgCRSVYLFw6b301wkInt1kZlbA7qZa9bqfPLvJzCxRyJZEtdruJ+duMjN7SeGDBIzsfjIzs5cUvrvJzMyyOUiYmVkmBwkzM8vkIGFmZpkcJMzMLFNLg4SkuZJWSXpE0kZJH0vLr5TUL6kv/Xlr1XMuk/SopM2Szm5l/czMrLFWT4HdA1waEQ9KehmwVtLd6WNfjogvVh8s6QTgD4ETgTnA9yW9OiIa5/Y2M7OWaGlLIiK2R8SD6e3ngEeARgsSzgW+FREvRsTjwKPAqa2so5mZZZu0MQlJ84BTgAfSoo9IekjS1yXNSst6ga1VT9tG46BiZmYtNClBQtIhwK3AxRHxS+A64FjgZGA78OeVQ+s8fVSiVkkXSVojac2OHTtaVGszM2t5kJBUIgkQN0XEbQAR8XREDEfEXuCrvNSltA2YW/X0o4Cnal8zIq6PiAURsWD27Nmt/QPMzAqspQPXkgR8DXgkIr5UVX5kRGxP774DeDi9fQfwj5K+RDJwfRzwo1bWEWDlun4n+DMzq6PVs5sWAn8EbJDUl5Z9ErhA0skkXUlPAH8MEBEbJa0AfkIyM+rDrZ7ZtHJdP5fdtoHBoeRt+gcGuey2DQAOFGZWeIrI2pttaliwYEGsWbNm3M/P2nSot6fM/UvO2p+qmZl1LElrI2JBs+MKv+I6a5tSb19qZuYgkblNqbcvNTPzpkMsPnv+iDEJGLl96UQPanuQ3MymksKPSUD2ibt2UBuShRxBMmYx1hN8vdcrl7q55p0nOVCY2aTKOyZR+JYEZG9feu1dm0ec0OGllX39A4MsvmX9vufnUe/1BoeGufauzQ4SZtaRChkkalsOZx4/m1WbdvDUwCCHlktIMLBraPRS7xpDw8FV39mY+wTvQXIzm2oKFyRWrutn8c3rGdqbhID+gUFuXL1l3+MDg0Njer2du/IfP6enXHe6rQfJzaxTFW5205V3bNwXICbb4rPnUy51jyirHiQ3M+s0hWtJjLWl0Ey5lD/OVrqlPLvJzKaKwgWJ8ejtKTOwazfP7x6dIaRL9RLXZssaJDcz60SF626aNbM05uecefzsugECyCw3M5sOChckrnjbiZS6R179d3eJnnJ28Fi1qfmeFSvX9bNw6b0cs+ROFi69l5Xr+ve7rmZm7Va4ILHolF6ufddr6e0pI5KupAtOncvBB2b3vDWbolpZJNc/MEjwUiZZBwozm+oKFyRqPf/iHpb/eGvdqakVzaaoNlokZ2Y2lRUuSNRe9Q8MDjE0nD0ltotk6mp3xgB1t9R0kZy7osxsqipckKh31d/IXmDNk7/ggtPm1n38oFJX5srsOT1ld0WZ2ZRWuCAxnhQYyx7YytWLTuJ9px+9r0UhkgHvrNlNlUVy7ooys6mscEFiPCkwhtNMuVcvOomfXfNWnlh6DnN6ygxnrNzu7Snvy+zqfE1mNpUVLkjM+7X6QeLAGWP7KLJO8oJ9254uXHpvZldUzzjWa5iZTbbCBYnVj+2sW/7inr0Nn1c76NxoR7vqcYgsU3wbDzMriMIFieFxnp1rB50bJevLMzj+7ATnkDIza4XCBYn9Vb1J0DXvPGnEorxm4xDVnB7czKYCJ/gbh2ZBIGvfiIqs9ODe/9rMOk3hWhK9E3AFf2i51HD9Q72uqMpSvOoWRzWvpzCzTlS4lsS8X2t8lV9NUHd20tDw3sz1Dxcv76O3p8x5r+/dtyVqnlaB9782s05UuCCRNbupnqwh7ud3D/P87uxA0z8wyK1r++u2GLJ4PYWZdaLCdTeNd3ZTraxcThVjXVXdaEqtmVm7tDRISJoraZWkRyRtlPSxtPwwSXdL+mn6e1ZaLkl/KelRSQ9Jel0r69fIAd2Ng0CeYDOWVoD3vzazTtTqlsQe4NKI+A3gdODDkk4AlgD3RMRxwD3pfYC3AMelPxcB17W4fpl2N8gMm3fD0rG0AhpNqTUza5eWjklExHZge3r7OUmPAL3AucAZ6WE3AD8A/nda/s2ICGC1pB5JR6av0zHKpS52DTVeoV3qErt27+GYJXeOGLhuNM3V+1+bWaeZtIFrSfOAU4AHgCMqJ/6I2C7pFelhvcDWqqdtS8tGBAlJF5G0NDj66KNbWu96mgWInnKJ53fvYeeuZFV1/8Aglyzv4+LlfSNmTFWmuQIODmbWkSZl4FrSIcCtwMUR8ctGh9YpG9XvExHXR8SCiFgwe/bsiarmhDn4wBmjNjKKmt8VThtuZp2s5UFCUokkQNwUEbelxU9LOjJ9/EjgmbR8G1C9u89RwFOtruNEG+u01f6BQe9aZ2YdqdWzmwR8DXgkIr5U9dAdwIXp7QuBb1eVvz+d5XQ68GynjUfk0dVkemw9XmVtZp2o1S2JhcAfAWdJ6kt/3gosBX5P0k+B30vvA3wXeAx4FPgq8Cctrl9L7M9aDHc/mVknafXspn8ne8bom+ocH8CHW1mnqcCrrM2sUxRuxXWnmDWzlJls0KuszaxTOEi0yc5dQ5x5fP2ZWVnlZmaTzUGijVZt2lG3/MbVWzzTycw6goNEm5RLXQ1Tlnumk5l1AgeJNhlssmo7OcYzncysvRwkOpxnOplZOxVu06GppksalSSwlvfGNrNWcZDocJWFeVnJACt7Y1e2PnXSQDObSLm7mySVJXkHnBbolhBJ9thZM0uI+jvf1RujaLQ3tpnZ/srVkpD0NuCLwAHAMZJOBj4TEW9vZeWKoEvw5+957air/mOW3Fn3+MoYRaWLKWuGlMcyzGwi5G1JXAmcCgwAREQfMK81VSqWvQFrnvzFqPJGe16vXNfP4lvWN5xC61XbZjYR8o5J7ImIZzWO7KbW3E2rt3D1opO4fOUGlj2wtWGCwDOPn81V39k4ar+Kat4b28wmSt4g8bCk/w50SzoO+Cjww9ZVq1gCuHzlBm5cvaXpsas27di34109vfsxu8mzpMysVt4g8b+ATwEvAsuAu4DPtqpSRbTsga3ND6L5WMP9S84acT/vid+zpMysnlxjEhGxKyI+FRG/mW4b+qmIeKHVlSuSvHtQjGWsoXrsorKp0eJb1tdN9eFZUmZWT64gIWmVpHtrf1pdORup1C0Wnz2fWTNLdR+vLa83djE0HFz1nY2jnpvVQvEsKbNiy9vd9PGq2wcB5wF7Jr461sjQcHDx8j5mzSzRpWRmVEWpW1zxthNHHJ81dlGvfE5Pue5sKc+SMiu2vN1Na6t+7o+IPwVOa3HdLMPOXUN0d4mecrLwbtbMEgcfMINLlveNO8X44rPnUy51jyjzLCkzy7uY7rCqu13A64Ffb0mNLJeh4eDgA2dw5dtPzBxw7imXGBgc3WroKY/urqoMTnt2k5lVy9vdtJZkpqZIupkeBz7UqkpZPv0Dg1y8vG9U+eDQMJeuWF93MLzUJa58+4mjyiEJFA4KZlYtV5CIiGNaXRGbWNUBQiQRfn/WUJhZMTUMEpLe2ejxiLhtYqtjrVAJELVrKMzMmmnWknhbg8cCcJCYIjyV1czGo2GQiIgPTlZFrLUqU1mdesPMxiL3pkOSzgFOJFknAUBEfKYVlbKJd+bxs516w8zGLO+K678DzifJ4STg3cArW1gvm2CrNu1w6g0zG7O8+0n8VkS8H9gZEVcBbwDmNnuSpK9LekbSw1VlV0rql9SX/ry16rHLJD0qabOks8f6x1i2/oHBzP0nGu1LYWbFlre7qXIW2SVpDvBzIM+02G8Afw18s6b8yxHxxeoCSScAf0jSpTUH+L6kV0fEMLbfKtuh1ls7UW+r1GoexzArrrwtiX+S1ANcCzwIPEGSMryhiLgPGL3tWn3nAt+KiBcj4nHgUZLd8KyBJ5aew/tOP7rpiX44IjPTbKMMtJVxjOpMspfdtmFcqT/MbOrJm7vpsxExEBG3koxFHB8Rn96P9/2IpIfS7qhZaVkvUL2pwra0zBqYt+ROlj2wlQtOm8sTS89pGizq6W2QxM/jGGbFlnfger2kT0o6Nr3Sf3Y/3vM64FjgZGA78OeVt6lzbN1LXEkXSVojac2OHTv2oyrTw3AEN67ewrwld+bel6KiWRI/pxA3K7a83U1vJ8nZtELSjyV9XNLR43nDiHg6IoYjYi/wVV7qUtrGyMHwo4CnMl7j+nTzowWzZ88eTzUKTyQtiGveeVLd8YXLV27g2Mu+Wz9K4xTiZkWRN3fTk8AXgC+ke1z/GfB5oLvhE+uQdGREbE/vvgOozHy6A/hHSV8iGbg+DvjRWF/fmps1s8S6T/9+5uPN9tt2CnGz4hjLYrp5wHtI1ksMA5/I8ZxlwBnA4ZK2AVcAZ0g6maQr6QngjwEiYqOkFcBPSFotH/bMptao9EhdvnIDyx7YynAE3RIXnDaXqxed1HC/7d6eMmceP5tr79rMJcv7PNvJbJrLu5/EA0AJWAG8OyIey/O8iLigTvHXGhz/OeBzeV7bxu/ZwaFRrYXKuEbldpbFZ8/3qm2zAsnbkrgwIja1tCY2aeb0lDNbC8se2Eq3lLmeotFsJwcJs+kn7xRYB4hp5MzjZzdcM3HBafUX019w2lzPdjIrmLyzm2waaTQo3S1x9aKTWHjsYSPKFx57GFcvOilzVpNnO5lNTw4SNsIFp81l5bp+HtwycinMD3/2C+YtuZPnX9xDqXvkkhbPdjKbvvIOXB8E/AnwRpJZSf8OXBcRL7SwbjaJqmc3LVx676hxh0rn1MDgEKUuMWtmiYFdQw1nNznnk9nUl3fg+pvAc8BfpfcvAP4vScpwmwZ+ds2+ZLxNxxeG9gYzD5jRcK2F964wmx7yBon5EfHaqvurJK1vRYVs8tXmQ5nTU26aPrxZIPEsKLPpIe+YxDpJp1fuSDoNuL81VbLJNvOAkQvnF589n3Kp8WL6ZgPVngVlNj3kDRKnAT+U9ISkJ4D/B/yOpA2SHmpZ7WxSPL97mIVL792X/nvRKb287uhDM48vdYvnX9zDMUvuHPE8SLqZFi691zmfzKaJvN1Nb25pLazt+gcGWXxL0oO45slfcP/P6m8DMmtmiV+9sIeBwaF9z6uMNQAjxiFqeRaU2dSTN0gcFxHfry6QdGFE3NCCOlmbDA0Hf7qij70ZzYBuiZkHzGDnrqER5dX7S2QFiF7PbjKbkvIGiU9LOg/4OHAI8PfAi4CDxDSTFSAgWY3daJ/srO2OBNy/5Kz9rpuZTb68QeJ3gEuBvvT+pyOi6falNr1k5XSqOLRc2tcNVVsOXjdhNhXlHbieRTJ4/TOSFsQrpXHsk2lT2umvmtXw8axvhOS9ss2mqrxBYjXwzxHxZuA3STYF8hTYgskazK6oHauoLvde2WZTU97upt+NiC0AETEIfFTSb7euWjbVdAlEdopxr5swm5ryBomtkt4HvCoiPpPub+28TbZPMuCdnX68N2MVdyesm/BYiVm2vN1Nfwu8gSRnEyR5nP6mJTWyaacy/bU2eywkYxO1C/ImU7OxksriwHoLB82KIG9L4rSIeJ2kdQARsVPSAS2sl00TIxbQZUyMqk3+l/fKfiJaAM3GSpyk0Ioub5AYktRN+t9c0mxgb8tqZVOeYMSJe+HSexlqsAhjrCfmicoymzUm0j8wyKUr1o8aY3GSQiuavEHiL4HbgVdI+hzwLuDyltXKprQuwWPXnDOiLM8A9VMDg02zx1ZaD/XGN8ZzAm+U8TZrTYgH261I8u5xfRPwCeAaYDuwKCJurjwuqfEEeiuUeg2GPAPUc3rKDWdBVY8fZBnrCTxPxtt69TQrirwtCSJiE7Ap4+F7gNdNSI1s2rh85QaWPbCV4QikpIWR1eNUGbvIaiXM6SnXbWXUO24sKq2OrPfNqqdZUUzUHtdefW37dJEEiBtXb9nXZRORBIiZpS4E9JRLzJpZQiSzn65550ksOqW37pV95cTcrJUw3hP4olN6uX/JWfRmBJhuaVQ9zYoid0uiiQZp4axo9gI3rt5S97HBob08vvScUeWVqaZPDQxyaLnEQaWuUXtoN7ra7+0pc+bxs7n2rs1csryPQ8slJJruw11t8dnzR6U6L5e6HRis0CYqSJjlUrmaqJ6+2jOzxLO7hvZNlxsYHKLUJb58/skjTs6NTuIwclZUdaLBvDOfqruevLDOLKFokNUz94tI6yLilAmoz5gtWLAg1qxZk/v4eUvubGFtLC/RvPnZUy7Rd8XvjyjLWhuxcOm9TccUenvKTllulpK0NiIWNDtuTC0JSa8ADqrcr+RzAt6UcfzXgT8AnomI16RlhwHLgXnAE8B70sV5Av4CeCuwC/hARDw4lvrZ1JHn0mRgcIiFS+8dcTW/6JTeulf2eafYmtnY5Bq4lvR2ST8FHgf+leTk/s+VxyMiKz3oNxi99ekS4J6IOI5kVtSStPwtwHHpz0XAdbn+ApvWKtuqNkuTkXeKrZmNTd7ZTZ8FTgf+IyKOIWk5NE0VHhH3AbUB5Fxe2tHuBmBRVfk3I7Ea6JF0ZM762TQ2NBxc9Z2NDfMsnXn87Iav4amrZuOTOy1HRPxcUpekrohYJenz43zPIyJiO0BEbE+7sAB6ga1Vx21Ly7aP831sGtm5a4iLl/eNKh8cGubi5X10N9gDy/trm41f3iAxIOkQ4D7gJknPAHsmuC71/pfX7bqWdBFJlxRHH330BFfDpqKsFBreX9ts/+QNEueS7B9xCfBe4FDgM+N8z6clHZm2Io4EnknLtwFzq447Cniq3gtExPXA9ZDMbhpnPawA6o1DVK8E75a44LS5XL3opDbUzqzz5QoSEfF81d0bMg/M5w7gQmBp+vvbVeUfkfQtkv20n610S5mNV+1YRWUleMVwBDeu3sLtD/aza/fwhK2N8EZGNl00DBKSnqN+l4+AiIiXN3n+MuAM4HBJ24ArSILDCkkfArYA704P/y7J9NdHSabAfjD/n2FW342rt7Bq0459J+mbMlaCP7974vaMmKg05madoGGQiIiX7c+LR8QFGQ+NWlcRyaq+D+/P+5nVU32SztM3ub97RjRLd242lUxUgj+zjla9qVEe+7PwrlG6c7OpxkHCCiNPKvCK/Vl4l/VcL+azqcgJ/sxqVC+8azQAnfVYViLCZov5PNhtnchBwgqtkmJ81aYdo07O9QagL1nex8XL++gpl3h+9x6GhmPfY7WD02M54Xuw2zqVg4QVWqOFdvUGoCsD39WpyCuqB6ezEhGO5b082F0sndqSdJCwwstaXDeegeaxjHvASyeGrOd5sLsYOrkl6SBhhZa1uC5rZ71m6uWQyrpCXLmun8U3r2coa+NvJn6wu1OvVouuk1uSE7LpUDt50yHbH1Ky//ZE6q0NBLes3zd2MeK9abxuY6K3Tq29Wm3Fe9hoeQLzMUvuzPwuCFoS0PNuOuQpsFZorbhG6h8YZPHNyR4YV31nY90AAY0DRG9PecJP3o2uVq01GqW3r9aoxVh53iXL+5hXs4/KZHCQMGuBob3BJcv72Llr9AB3HvcvOavpbKh6my814kV+ky9vYF589nzKpe6Gr1W5qMgKNK3iMQmzFhlvI2XWzBKQfyyj0nKBxoOcc3rKdQfIvcivdfIG5tpp082+O4NDw1y6Yj2XLO9r+diSg4RZB+kSXPG2ExvOdrnyjo2jBruH9gZX3rGx4YlivIv8Jlt1cDy0XEKCgV1DHT3QnhXQswJzQMP92xcuvbfpTLnKHiqtngnlgWuzDtQt1d1IqTfjpFPxxNJzGr5uO2c3VU81lqA8o4vBob0NFzDW6sSB9kYTAoCGf0+pSxxy0IxRQbDZ51BPb095TBts5R24dkvCrANl7bTXbPyg9uq01lgX+e2P6oBULnWxa2jvvsci2He/+kq4Xh9+tU6ZFlqt0bhD5aSdtRZmaG/sG7fKWrWfd+1Nq8aWHCTMppBm7f684xMTpdG4SfWVcHWAqKdyUs1zopvMgfY8La9m4w6VwNxommtFZc/2a+/aPGrDrGZ60rGsieYgYTbNDO0NLlnR13RQs/oE2DOzRAQ8O5i/77/RuEmzFkE9lRNxsyvnyRpoz7sK+tByqW6alkPLI0/aef62iv6BwTEv6GzVyIGnwJpNQxEvza//0xV9o6ZL1s7f37lriIHBoYZz+Ws16mYZz9X+nDTZYiOTOdCed/pqnUX2I8or05XHmrJlrJ6tE6gmgoOE2TS3N+CTtz00oixv338jjbpZxnq1X+oSi8+ez6pNOzKP6e0pc97re7n2rs1N14eMZx1JrbzTVwcy1sIM7BoaEYwnSu8k71fiIGFWALuG9nLsZd/l8pVJd0meK/3+gcG6J9nKCTird6PSXVW7OKxL2Vfde0mm9madTEUyhffWtf1NVy/nXeXcTN7No7KOC+DSFeubdrvVy/fVyK7deyh1jXxOK1tYngJrVjDlUjL1dCwqeaZq99EY/dovTVHNyq47nq6XytVzvefVTv3Mev2sKaJ5B98b/X2TrdQtDj5gxpjGkGp5CqyZ1TXWAAGN99GoqGzgdO1dm7l4ed+IBIbDEdy6tp8FrzxszAGicpV88fK+uo/Xvt5Y0o/kGZyuF0BqswdPtqHh4LkX9kzKezlImNl+q3QHVZ9wa6+vK+McWQsF65mVzrq6JCNAwEvdNZUWQaNusFrNUnRXryupvP4ly/vGnXJlIk3WimsHCTPbb5X+92Yn/7G0InrKJV4Y2tu0T384glM+8z1+9cKezL05svrs87Y6GqV87wStXGTogWszmxB5WwdZs3OqVQa586612LlrKDNANEq73mjQuXrAvlHK907hFddm1hEq+YbGmwY9T2tibzDu168mRu9jXruIsNSlugGmuhtnIurSarWL9yaKWxJmlltvT5nzT53LzAOmxvVlbUuh3iJClHRt1VNJyT0VDA2PfUJCHlPjX9rMOsJTA4Ms+9FWhhvsy90p6o1D1BuoHhoODj5wRubMrXZMcR2P53ePLQ1KXm0LEpKeAJ4DhoE9EbFA0mHAcmAe8ATwnojY2a46mtlIAVMiQEggkt0BK8nyVm3akdnV1eqUGVNZu7ubzoyIk6sWdCwB7omI44B70vtmZmNSSUVeWXF94+ot0z4QjG3ddn7tDhK1zgVuSG/fACxqY13MzKaMVrXv2hkkAviepLWSLkrLjoiI7QDp71fUe6KkiyStkbRmx47shGBmZkUxaxruJ7EwIp6S9Argbkmb8j4xIq4Hrockd1OrKmhmNlW8MMb9O/JqW0siIp5Kfz8D3A6cCjwt6UiA9Pcz7aqfmdlUMp6cXHm0JUhIOljSyyq3gd8HHgbuAC5MD7sQ+HY76mdmZol2dTcdAdyuJDHXDOAfI+JfJP0YWCHpQ8AW4N1tqp+Z2ZTS1aLpTW0JEhHxGPDaOuU/B940+TUyM+sclbTrjdZ21GrV8hWvuDYz6zD9A4PcvfE/+a9f5c8ZNR1nN5mZWYann9s9puN/9UJrkhB22mI6MzMbhxZNbnKQMDOzbA4SZmaWyUHCzMwyOUiYmVkmBwkzM8vkIGFmZpkcJMzMLJODhJmZZXKQMDOzTA4SZmaWyUHCzMwyOUiYmVkmBwkzM8vkIGFmZpkcJMzMLJODhJmZZXKQMDOzTA4SZmaWyUHCzMwyOUiYmVkmBwkzM8vkIGFmZpkcJMzMLFPHBQlJb5a0WdKjkpa0uz5mZkXWUUFCUjfwN8BbgBOACySd0N5amZkVV0cFCeBU4NGIeCwidgPfAs5tc53MzAqr04JEL7C16v62tMzMzNqg04KE6pTFqIOkiyStkbRmx44dk1AtM7Ni6rQgsQ2YW3X/KOCp2oMi4vqIWBARC2bPnj1plTMzK5pOCxI/Bo6TdIykA4A/BO5oc53MzAqro4JEROwBPgLcBTwCrIiIjRP5Hk8sPWciX87MrCO06tw2oyWvuh8i4rvAd1v5Hg4UZmb5dFRLwszMOouDhJmZZXKQMDOzTA4SZmaWyUHCzMwyKWLUguYpRdIO4Ml212McDgf+q92V6ED+XEbzZzKaP5PRxvqZvDIimq5GnvJBYqqStCYiFrS7Hp3Gn8to/kxG82cyWqs+E3c3mZlZJgcJMzPL5CDRPte3uwIdyp/LaP5MRvNnMlpLPhOPSZiZWSa3JMzMLJODxCSQNFfSKkmPSNoo6WNp+WGS7pb00/T3rHbXdbJJ6pa0TtI/pfePkfRA+pksT1PGF4akHkm3SNqUfl/eUPTviaRL0v83D0taJumgIn5PJH1d0jOSHq4qq/vdUOIvJT0q6SFJrxvv+zpITI49wKUR8RvA6cCHJZ0ALAHuiYjjgHvS+0XzMZK08BWfB76cfiY7gQ+1pVbt8xfAv0TE8cBrST6bwn5PJPUCHwUWRMRrgG6SfWaK+D35BvCWcX0KAAAGpElEQVTmmrKs78ZbgOPSn4uA68b7pg4SkyAitkfEg+nt50j+4/cC5wI3pIfdACxqTw3bQ9JRwDnA36f3BZwF3JIeUqjPRNLLgd8GvgYQEbsjYoCCf09ItjQoS5oBzAS2U8DvSUTcB/yipjjru3Eu8M1IrAZ6JB05nvd1kJhkkuYBpwAPAEdExHZIAgnwivbVrC2+AnwC2Jve/zVgIN18CpLtbHvbUbE2eRWwA/iHtAvu7yUdTIG/JxHRD3wR2EISHJ4F1lLs70m1rO9GL7C16rhxf0YOEpNI0iHArcDFEfHLdtennST9AfBMRKytLq5zaJGm380AXgdcFxGnAM9ToK6letI+9nOBY4A5wMEkXSm1ivQ9yWPC/i85SEwSSSWSAHFTRNyWFj9daQKmv59pV/3aYCHwdklPAN8i6T74CkmzuLJj4lHAU+2pXltsA7ZFxAPp/VtIgkaRvye/CzweETsiYgi4Dfgtiv09qZb13dgGzK06btyfkYPEJEj72r8GPBIRX6p66A7gwvT2hcC3J7tu7RIRl0XEURExj2Qg8t6IeC+wCnhXeljRPpP/BLZKmp8WvQn4CQX+npB0M50uaWb6/6jymRT2e1Ij67txB/D+dJbT6cCzlW6psfJiukkg6Y3AvwEbeKn//ZMk4xIrgKNJ/jO8OyJqB6amPUlnAB+PiD+Q9CqSlsVhwDrgfRHxYjvrN5kknUwykH8A8BjwQZKLucJ+TyRdBZxPMktwHfA/SPrXC/U9kbQMOIMk2+vTwBXASup8N9KA+tcks6F2AR+MiDXjel8HCTMzy+LuJjMzy+QgYWZmmRwkzMwsk4OEmZllcpAwM7NMDhJmTUj6n5Le3+56jEWaTfZPqu7PkXRLo+eY1eMpsGZTlKQZVfmLah+bB/xTmjnVbNzckrCOJenP0n0V7k73Efh4Wn6spH+RtFbSv0k6Pi3/RppD/4eSHpP0rrRckq5N9yPYIOn8tPwMSf8qaYWk/5C0VNJ7Jf0oPe7Y9Lgrq977v0n6vqT1kh6sHFNV54Ml3Zk+/nDVe70+fa+1ku6qSqXwA0lfSev8sKRT0/JT07J16e/5afkHJN0s6TvA9yQdIumetC4bJJ2bVmUpcKykvvRvn6d0HwIl+zH8Q3r8OklnVr32beln+1NJX2jZP65NHRHhH/903A+wAOgDysDLgJ+SrMqGJG/+cent00hSekCSb/9mkoufE4BH0/LzgLtJ9iI4gmRl6pEkq1cH0tsHAv3AVelzPgZ8Jb19ZdV7PwC8I719EDCzpt7nAV+tun8oUAJ+CMxOy84Hvp7e/kHleJI04Q+nt18OzEhv/y5wa3r7AyR5eQ5L788AXp7ePhx4lCS527zKa6WPzat67UuBf0hvH59+Hgelr/1YWueDgCeBue3+LvinvT+VBFlmneaNwLcjYhAgvXKuZNL9LeDmJPMAkJzgK1ZGxF7gJ5KOqHqtZRExTJIQ7V+B3wR+Cfw40pw2kn4GfC99zgbgzOoKSXoZ0BsRtwNExAt16r0B+KKkz5N09/ybpNcArwHuTuvcTZL2umJZ+nr3SXq5pB6SwHiDpONIsneWqo6/O15KyyHg/0j6bZKUL70kgbCRNwJ/lb7nJklPAq9OH7snIp5N/96fAK9kZMppKxgHCetU9VIdQ9JKGIiIkzMer87fo5rfzY7fW3V/L6P/fzR6HQAi4j8kvR54K3CNpO8BtwMbI+INWU+rc/+zwKqIeEc6vvCDqsefr7r9XmA28PqIGFKSVfegJtXM+3kM43NE4XlMwjrVvwNvS/vPDyHZwY5I9uF4XNK7Yd94w2ubvNZ9wPlK9tOeTdKt86OxVih9722SFqXvfaCkmdXHSJoD7IqIG0k2y3kdsBmYLekN6TElSSdWPa0ybvFGkmydz5J0+fSnj3+gQbUOJdmXYygdW3hlWv4cSWuknvtIgguSXk2SHG5zkz/fCspBwjpSRPyYJN3xepI9BNaQ7EoGyQnuQ5LWAxtJNqVp5HbgofS17gU+EUla7vH4I+Cjkh4iGWf49ZrHTwJ+JKkP+BRwdUTsJklr/fm0zn0kXWYVOyX9EPg7Xtqr+QskLZH7SbqnstwELJC0huRz2QQQET8H7k8Hw6+tec7fAt2SNgDLgQ/ENM+gauPnKbDWsSQdEhG/Sq/W7wMuinSv8OlC0g9IBsXHlcbZrNXc32id7HpJJ5D0sd8w3QKE2VTgloSZmWXymISZmWVykDAzs0wOEmZmlslBwszMMjlImJlZJgcJMzPL9P8BHiH9ldrRdaYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# also supplementary stuff to note\n",
    "# about the previous point - how do we ended up having super small la_exp at small genomic separatrions ...\n",
    "xlabel = 'la_exp.donut.value'\n",
    "ylabel = 'count'\n",
    "\n",
    "plt.scatter(la_exp['bin2_id']-la_exp['bin1_id'],(la_exp[xlabel]))\n",
    "# plt.scatter(dddd[xlabel],dddd[ylabel], s=80, facecolors='none', edgecolors='r')\n",
    "# plt.scatter(eeee[xlabel],eeee[ylabel], s=80, facecolors='none', edgecolors='y')\n",
    "\n",
    "ax = plt.gca()\n",
    "\n",
    "ax.set_xlabel(\"genomic separation\")\n",
    "ax.set_ylabel(\"la_exp value\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
